How to use

CachedCrudAssist

in

org.apache.kylin.metadata.cachesync

public void reloadAll() throws IOException {
  try (AutoReadWriteLock.AutoLock lock = executableDigestMapLock.lockForWrite()) {
    executableDigestCrud.reloadAll();
  }
  try (AutoReadWriteLock.AutoLock lock = executableOutputDigestMapLock.lockForWrite()) {
    executableOutputDigestCrud.reloadAll();
  }
}

  @Override
  public void onEntityChange(Broadcaster broadcaster, String entity, Broadcaster.Event event, String cacheKey)
      throws IOException {
    try (AutoReadWriteLock.AutoLock l = lock.lockForWrite()) {
      if (event == Broadcaster.Event.DROP)
        userMap.removeLocal(cacheKey);
      else
        crud.reloadQuietly(cacheKey);
    }
  }
}

public void saveExternalFilter(ExternalFilterDesc desc) throws IOException {
  try (AutoLock lock = extFilterMapLock.lockForWrite()) {
    extFilterCrud.save(desc);
  }
}

private void updateTempStatementWithRetry(TempStatementEntity entity, int retry) throws IOException {
  try {
    crud.save(entity);
  } catch (WriteConflictException ise) {
    logger.warn("Write conflict to update temp statement" + entity.statementId + " at try " + retry
        + ", will retry...");
    if (retry >= 7) {
      logger.error("Retried 7 times till got error, abandoning...", ise);
      throw ise;
    }
    TempStatementEntity reload = crud.reload(entity.resourceName());
    entity = prepareToOverwrite(entity, reload);
    updateTempStatementWithRetry(entity, ++retry);
  }
}

public T save(T entity) throws IOException {
  Preconditions.checkArgument(entity != null);
  completeUuidIfNeeded(entity);
  Preconditions.checkArgument(entityType.isInstance(entity));
  String resName = entity.resourceName();
  Preconditions.checkArgument(resName != null && resName.length() > 0);
  if (checkCopyOnWrite) {
    if (entity.isCachedAndShared() || cache.get(resName) == entity) {
      throw new IllegalStateException("Copy-on-write violation! The updating entity " + entity
          + " is a shared object in " + entityType.getSimpleName() + " cache, which should not be.");
    }
  }
  String path = resourcePath(resName);
  logger.debug("Saving {} at {}", entityType.getSimpleName(), path);
  store.checkAndPutResource(path, entity, serializer);
  
  // just to trigger the event broadcast, the entity won't stay in cache
  cache.put(resName, entity);
  // keep the pass-in entity out of cache, the caller may use it for further update
  // return a reloaded new object
  return reload(resName);
}

private CubeManager(KylinConfig cfg) throws IOException {
  logger.info("Initializing CubeManager with config {}", cfg);
  this.config = cfg;
  this.cubeMap = new CaseInsensitiveStringCache<CubeInstance>(config, "cube");
  this.crud = new CachedCrudAssist<CubeInstance>(getStore(), ResourceStore.CUBE_RESOURCE_ROOT, CubeInstance.class,
      cubeMap) {
    @Override
    protected CubeInstance initEntityAfterReload(CubeInstance cube, String resourceName) {
      cube.init(config);
      for (CubeSegment segment : cube.getSegments()) {
        usedStorageLocation.put(segment.getUuid(), segment.getStorageLocationIdentifier());
      }
      return cube;
    }
  };
  this.crud.setCheckCopyOnWrite(true);
  // touch lower level metadata before registering my listener
  crud.reloadAll();
  Broadcaster.getInstance(config).registerListener(new CubeSyncListener(), "cube");
}

public void removeKafkaConfig(KafkaConfig kafkaConfig) throws IOException {
  try (AutoLock l = lock.lockForWrite()) {
    crud.delete(kafkaConfig);
  }
}

private TableACL loadTableACL(String project) throws IOException {
  TableACL acl = crud.reload(project);
  if (acl == null) {
    acl = newTableACL(project);
  }
  return acl;
}

public void delete(String username) {
  try (AutoReadWriteLock.AutoLock l = lock.lockForWrite()) {
    crud.delete(username.toUpperCase(Locale.ROOT));
  } catch (IOException e) {
    throw new RuntimeException("Can not delete user.", e);
  }
}

  cube = crud.save(cube);
} catch (WriteConflictException ise) {
  logger.warn("Write conflict to update cube {} at try {}, will retry...", cube.getName(), retry);
  cube = crud.reload(cube.getName());
  update.setCubeInstance(cube.latestCopyForWrite());
  return updateCubeWithRetry(update, ++retry);

this.executableDigestCrud.setCheckCopyOnWrite(true);
this.executableDigestCrud.reloadAll();
this.executableOutputDigestCrud.setCheckCopyOnWrite(true);
this.executableOutputDigestCrud.reloadAll();
Broadcaster.getInstance(config).registerListener(new JobSyncListener(), "execute");
Broadcaster.getInstance(config).registerListener(new JobOutputSyncListener(), "execute_output");

public HybridInstance reloadHybridInstance(String name) {
  try (AutoLock l = lock.lockForWrite()) {
    return crud.reload(name);
  }
}

public T save(T entity) throws IOException {
  Preconditions.checkArgument(entity != null);
  completeUuidIfNeeded(entity);
  Preconditions.checkArgument(entityType.isInstance(entity));
  String resName = entity.resourceName();
  Preconditions.checkArgument(resName != null && resName.length() > 0);
  if (checkCopyOnWrite) {
    if (entity.isCachedAndShared() || cache.get(resName) == entity) {
      throw new IllegalStateException("Copy-on-write violation! The updating entity " + entity
          + " is a shared object in " + entityType.getSimpleName() + " cache, which should not be.");
    }
  }
  String path = resourcePath(resName);
  logger.debug("Saving {} at {}", entityType.getSimpleName(), path);
  store.checkAndPutResource(path, entity, serializer);
  
  // just to trigger the event broadcast, the entity won't stay in cache
  cache.put(resName, entity);
  // keep the pass-in entity out of cache, the caller may use it for further update
  // return a reloaded new object
  return reload(resName);
}

  @Override
  public void onEntityChange(Broadcaster broadcaster, String entity, Event event, String cacheKey)
      throws IOException {
    try (AutoLock l = lock.lockForWrite()) {
      if (event == Event.DROP)
        kafkaMap.removeLocal(cacheKey);
      else
        crud.reloadQuietly(cacheKey);
    }
  }
}

public void reloadAllHybridInstance() throws IOException {
  try (AutoLock l = lock.lockForWrite()) {
    crud.reloadAll();
  }
}

public void saveSourceTable(TableDesc srcTable, String prj) throws IOException {
  try (AutoLock lock = srcTableMapLock.lockForWrite()) {
    srcTable.init(config, prj);
    srcTableCrud.save(srcTable);
  }
}

public void removeExternalFilter(String name) throws IOException {
  try (AutoLock lock = extFilterMapLock.lockForWrite()) {
    extFilterCrud.delete(name);
  }
}

private void updateTempStatementWithRetry(TempStatementEntity entity, int retry) throws IOException {
  try {
    crud.save(entity);
  } catch (WriteConflictException ise) {
    logger.warn("Write conflict to update temp statement" + entity.statementId + " at try " + retry
        + ", will retry...");
    if (retry >= 7) {
      logger.error("Retried 7 times till got error, abandoning...", ise);
      throw ise;
    }
    TempStatementEntity reload = crud.reload(entity.resourceName());
    entity = prepareToOverwrite(entity, reload);
    updateTempStatementWithRetry(entity, ++retry);
  }
}

private CubeManager(KylinConfig cfg) throws IOException {
  logger.info("Initializing CubeManager with config {}", cfg);
  this.config = cfg;
  this.cubeMap = new CaseInsensitiveStringCache<CubeInstance>(config, "cube");
  this.crud = new CachedCrudAssist<CubeInstance>(getStore(), ResourceStore.CUBE_RESOURCE_ROOT, CubeInstance.class,
      cubeMap) {
    @Override
    protected CubeInstance initEntityAfterReload(CubeInstance cube, String resourceName) {
      cube.init(config);
      for (CubeSegment segment : cube.getSegments()) {
        usedStorageLocation.put(segment.getUuid(), segment.getStorageLocationIdentifier());
      }
      return cube;
    }
  };
  this.crud.setCheckCopyOnWrite(true);
  // touch lower level metadata before registering my listener
  crud.reloadAll();
  Broadcaster.getInstance(config).registerListener(new CubeSyncListener(), "cube");
}

public DataModelDesc reloadDataModel(String modelName) {
  try (AutoLock lock = modelMapLock.lockForWrite()) {
    return crud.reload(modelName);
  }
}