How to use

reloadQuietly

method

in

org.apache.kylin.metadata.cachesync.CachedCrudAssist

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

public void reloadSourceTableQuietly(String table, String project) {
  try (AutoLock lock = srcTableMapLock.lockForWrite()) {
    srcTableCrud.reloadQuietly(TableDesc.concatResourcePath(table, project));
  }
}

public CubeInstance reloadCubeQuietly(String cubeName) {
  try (AutoLock lock = cubeMapLock.lockForWrite()) {
    CubeInstance cube = crud.reloadQuietly(cubeName);
    if (cube != null)
      Cuboid.clearCache(cube);
    return cube;
  }
}

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

  @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);
    }
  }
}

  @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);
    }
  }
}

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

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

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

public void reloadTableExtQuietly(String table, String project) {
  try (AutoLock lock = srcExtMapLock.lockForWrite()) {
    srcExtCrud.reloadQuietly(TableExtDesc.concatResourcePath(table, project));
  }
}

public ProjectInstance reloadProjectQuietly(String project) throws IOException {
  try (AutoLock lock = prjMapLock.lockForWrite()) {
    ProjectInstance prj = crud.reloadQuietly(project);
    clearL2Cache(project);
    return prj;
  }
}

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

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

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

@Override
public void onProjectSchemaChange(Broadcaster broadcaster, String project) throws IOException {
  try (AutoLock l = lock.lockForWrite()) {
    for (IRealization real : ProjectManager.getInstance(config).listAllRealizations(project)) {
      if (real instanceof HybridInstance) {
        crud.reloadQuietly(real.getName());
      }
    }
  }
}

  @Override
  public void onEntityChange(Broadcaster broadcaster, String entity, Event event, String cacheKey)
      throws IOException {
    if ("hybrid".equals(entity)) {
      String hybridName = cacheKey;
      try (AutoLock l = lock.lockForWrite()) {
        if (event == Event.DROP)
          hybridMap.removeLocal(hybridName);
        else
          crud.reloadQuietly(hybridName);
      }
      for (ProjectInstance prj : ProjectManager.getInstance(config).findProjects(RealizationType.HYBRID,
          hybridName)) {
        broadcaster.notifyProjectSchemaUpdate(prj.getName());
      }
    } else if ("cube".equals(entity)) {
      String cubeName = cacheKey;
      try (AutoLock l = lock.lockForWrite()) {
        for (HybridInstance hybrid : getHybridInstancesByChild(RealizationType.CUBE, cubeName)) {
          crud.reloadQuietly(hybrid.getName());
        }
      }
    }
  }
}

@Override
public void onProjectSchemaChange(Broadcaster broadcaster, String project) throws IOException {
  //clean up the current project's table desc
  TableMetadataManager.getInstance(config).resetProjectSpecificTableDesc(project);
  try (AutoLock lock = modelMapLock.lockForWrite()) {
    for (String model : ProjectManager.getInstance(config).getProject(project).getModels()) {
      crud.reloadQuietly(model);
    }
  }
}

  @Override
  public void onEntityChange(Broadcaster broadcaster, String entity, Event event, String cacheKey)
      throws IOException {
    try (AutoLock lock = modelMapLock.lockForWrite()) {
      if (event == Event.DROP)
        dataModelDescMap.removeLocal(cacheKey);
      else
        crud.reloadQuietly(cacheKey);
    }
    for (ProjectInstance prj : ProjectManager.getInstance(config).findProjectsByModel(cacheKey)) {
      broadcaster.notifyProjectSchemaUpdate(prj.getName());
    }
  }
}

  @Override
  public void onEntityChange(Broadcaster broadcaster, String entity, Event event, String cacheKey)
      throws IOException {
    try (AutoLock lock = srcTableMapLock.lockForWrite()) {
      if (event == Event.DROP)
        srcTableMap.removeLocal(cacheKey);
      else
        srcTableCrud.reloadQuietly(cacheKey);
    }
    Pair<String, String> pair = TableDesc.parseResourcePath(cacheKey);
    String table = pair.getFirst();
    String prj = pair.getSecond();
    if (prj == null) {
      for (ProjectInstance p : ProjectManager.getInstance(config).findProjectsByTable(table)) {
        broadcaster.notifyProjectSchemaUpdate(p.getName());
      }
    } else {
      broadcaster.notifyProjectSchemaUpdate(prj);
    }
  }
}

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