How to use

HiveClientCache$HiveClientCacheKey

in

org.apache.hive.hcatalog.common

/**
 * Returns a cached client if exists or else creates one, caches and returns it. It also checks that the client is
 * healthy and can be reused
 * @param hiveConf
 * @return the hive client
 * @throws MetaException
 * @throws IOException
 * @throws LoginException
 */
public IMetaStoreClient get(final HiveConf hiveConf) throws MetaException, IOException, LoginException {
 final HiveClientCacheKey cacheKey = HiveClientCacheKey.fromHiveConf(hiveConf, getThreadId());
 ICacheableMetaStoreClient cacheableHiveMetaStoreClient = null;
 // the hmsc is not shared across threads. So the only way it could get closed while we are doing healthcheck
 // is if removalListener closes it. The synchronization takes care that removalListener won't do it
 synchronized (CACHE_TEARDOWN_LOCK) {
  cacheableHiveMetaStoreClient = getOrCreate(cacheKey);
  cacheableHiveMetaStoreClient.acquire();
 }
 if (!cacheableHiveMetaStoreClient.isOpen()) {
  synchronized (CACHE_TEARDOWN_LOCK) {
   hiveCache.invalidate(cacheKey);
   cacheableHiveMetaStoreClient.close();
   cacheableHiveMetaStoreClient = getOrCreate(cacheKey);
   cacheableHiveMetaStoreClient.acquire();
  }
 }
 return cacheableHiveMetaStoreClient;
}

 @Override
 public ICacheableMetaStoreClient call() throws MetaException {
  // This is called from HCat, so always allow embedded metastore (as was the default).
  return
    (ICacheableMetaStoreClient) RetryingMetaStoreClient.getProxy(cacheKey.getHiveConf(),
      new Class<?>[]{HiveConf.class, Integer.class, Boolean.class},
      new Object[]{cacheKey.getHiveConf(), timeout, true},
      CacheableHiveMetaStoreClient.class.getName());
 }
});

/**
 * Returns a cached client if exists or else creates one, caches and returns it. It also checks that the client is
 * healthy and can be reused
 * @param hiveConf
 * @return the hive client
 * @throws MetaException
 * @throws IOException
 * @throws LoginException
 */
public ICacheableMetaStoreClient get(final HiveConf hiveConf) throws MetaException, IOException, LoginException {
 final HiveClientCacheKey cacheKey = HiveClientCacheKey.fromHiveConf(hiveConf, getThreadId());
 ICacheableMetaStoreClient cacheableHiveMetaStoreClient = null;
 // the hmsc is not shared across threads. So the only way it could get closed while we are doing healthcheck
 // is if removalListener closes it. The synchronization takes care that removalListener won't do it
 synchronized (CACHE_TEARDOWN_LOCK) {
  cacheableHiveMetaStoreClient = getOrCreate(cacheKey);
  cacheableHiveMetaStoreClient.acquire();
 }
 if (!cacheableHiveMetaStoreClient.isOpen()) {
  synchronized (CACHE_TEARDOWN_LOCK) {
   hiveCache.invalidate(cacheKey);
   cacheableHiveMetaStoreClient.close();
   cacheableHiveMetaStoreClient = getOrCreate(cacheKey);
   cacheableHiveMetaStoreClient.acquire();
  }
 }
 return cacheableHiveMetaStoreClient;
}

/**
 * Returns a cached client if exists or else creates one, caches and returns it. It also checks that the client is
 * healthy and can be reused
 * @param hiveConf
 * @return the hive client
 * @throws MetaException
 * @throws IOException
 * @throws LoginException
 */
public ICacheableMetaStoreClient get(final HiveConf hiveConf) throws MetaException, IOException, LoginException {
 final HiveClientCacheKey cacheKey = HiveClientCacheKey.fromHiveConf(hiveConf, getThreadId());
 ICacheableMetaStoreClient cacheableHiveMetaStoreClient = null;
 // the hmsc is not shared across threads. So the only way it could get closed while we are doing healthcheck
 // is if removalListener closes it. The synchronization takes care that removalListener won't do it
 synchronized (CACHE_TEARDOWN_LOCK) {
  cacheableHiveMetaStoreClient = getOrCreate(cacheKey);
  cacheableHiveMetaStoreClient.acquire();
 }
 if (!cacheableHiveMetaStoreClient.isOpen()) {
  synchronized (CACHE_TEARDOWN_LOCK) {
   hiveCache.invalidate(cacheKey);
   cacheableHiveMetaStoreClient.close();
   cacheableHiveMetaStoreClient = getOrCreate(cacheKey);
   cacheableHiveMetaStoreClient.acquire();
  }
 }
 return cacheableHiveMetaStoreClient;
}

/**
 * Returns a cached client if exists or else creates one, caches and returns it. It also checks that the client is
 * healthy and can be reused
 * @param hiveConf
 * @return the hive client
 * @throws MetaException
 * @throws IOException
 * @throws LoginException
 */
public ICacheableMetaStoreClient get(final HiveConf hiveConf) throws MetaException, IOException, LoginException {
 final HiveClientCacheKey cacheKey = HiveClientCacheKey.fromHiveConf(hiveConf, getThreadId());
 ICacheableMetaStoreClient cacheableHiveMetaStoreClient = null;
 // the hmsc is not shared across threads. So the only way it could get closed while we are doing healthcheck
 // is if removalListener closes it. The synchronization takes care that removalListener won't do it
 synchronized (CACHE_TEARDOWN_LOCK) {
  cacheableHiveMetaStoreClient = getOrCreate(cacheKey);
  cacheableHiveMetaStoreClient.acquire();
 }
 if (!cacheableHiveMetaStoreClient.isOpen()) {
  synchronized (CACHE_TEARDOWN_LOCK) {
   hiveCache.invalidate(cacheKey);
   cacheableHiveMetaStoreClient.close();
   cacheableHiveMetaStoreClient = getOrCreate(cacheKey);
   cacheableHiveMetaStoreClient.acquire();
  }
 }
 return cacheableHiveMetaStoreClient;
}

/**
 * Returns a cached client if exists or else creates one, caches and returns it. It also checks that the client is
 * healthy and can be reused
 * @param hiveConf
 * @return the hive client
 * @throws MetaException
 * @throws IOException
 * @throws LoginException
 */
public IMetaStoreClient get(final HiveConf hiveConf) throws MetaException, IOException, LoginException {
 final HiveClientCacheKey cacheKey = HiveClientCacheKey.fromHiveConf(hiveConf, getThreadId());
 ICacheableMetaStoreClient cacheableHiveMetaStoreClient = null;
 // the hmsc is not shared across threads. So the only way it could get closed while we are doing healthcheck
 // is if removalListener closes it. The synchronization takes care that removalListener won't do it
 synchronized (CACHE_TEARDOWN_LOCK) {
  cacheableHiveMetaStoreClient = getOrCreate(cacheKey);
  cacheableHiveMetaStoreClient.acquire();
 }
 if (!cacheableHiveMetaStoreClient.isOpen()) {
  synchronized (CACHE_TEARDOWN_LOCK) {
   hiveCache.invalidate(cacheKey);
   cacheableHiveMetaStoreClient.close();
   cacheableHiveMetaStoreClient = getOrCreate(cacheKey);
   cacheableHiveMetaStoreClient.acquire();
  }
 }
 return cacheableHiveMetaStoreClient;
}

public static HiveClientCacheKey fromHiveConf(HiveConf hiveConf, final int threadId) throws IOException, LoginException {
 return new HiveClientCacheKey(hiveConf, threadId);
}

public static HiveClientCacheKey fromHiveConf(HiveConf hiveConf, final int threadId) throws IOException, LoginException {
 return new HiveClientCacheKey(hiveConf, threadId);
}

public static HiveClientCacheKey fromHiveConf(HiveConf hiveConf, final int threadId) throws IOException, LoginException {
 return new HiveClientCacheKey(hiveConf, threadId);
}

public static HiveClientCacheKey fromHiveConf(HiveConf hiveConf, final int threadId) throws IOException, LoginException {
 return new HiveClientCacheKey(hiveConf, threadId);
}

 @Override
 public ICacheableMetaStoreClient call() throws MetaException {
  return
    (ICacheableMetaStoreClient) RetryingMetaStoreClient.getProxy(cacheKey.getHiveConf(),
      new Class<?>[]{HiveConf.class, Integer.class},
      new Object[]{cacheKey.getHiveConf(), timeout},
      CacheableHiveMetaStoreClient.class.getName());
 }
});

 @Override
 public ICacheableMetaStoreClient call() throws MetaException {
  // This is called from HCat, so always allow embedded metastore (as was the default).
  return
    (ICacheableMetaStoreClient) RetryingMetaStoreClient.getProxy(cacheKey.getHiveConf(),
      new Class<?>[]{HiveConf.class, Integer.class, Boolean.class},
      new Object[]{cacheKey.getHiveConf(), timeout, true},
      CacheableHiveMetaStoreClient.class.getName());
 }
});

 @Override
 public ICacheableMetaStoreClient call() throws MetaException {
  return
    (ICacheableMetaStoreClient) RetryingMetaStoreClient.getProxy(cacheKey.getHiveConf(),
      new Class<?>[]{HiveConf.class, Integer.class},
      new Object[]{cacheKey.getHiveConf(), timeout},
      CacheableHiveMetaStoreClient.class.getName());
 }
});

 @Override
 public ICacheableMetaStoreClient call() throws MetaException {
  return
    (ICacheableMetaStoreClient) RetryingMetaStoreClient.getProxy(cacheKey.getHiveConf(),
      new Class<?>[]{HiveConf.class, Integer.class},
      new Object[]{cacheKey.getHiveConf(), timeout},
      CacheableHiveMetaStoreClient.class.getName());
 }
});

public static HiveClientCacheKey fromHiveConf(HiveConf hiveConf, final int threadId) throws IOException, LoginException {
 return new HiveClientCacheKey(hiveConf, threadId);
}