public ExecutableOutputPO getJobOutputDigest(String uuid) { return executableOutputDigestMap.get(uuid); }
@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 List<DataModelDesc> getModels() { try (AutoLock lock = modelMapLock.lockForRead()) { return new ArrayList<>(dataModelDescMap.values()); } }
@Nullable private AclRecord getAclRecordByCache(String id) { try (AutoLock l = lock.lockForRead()) { if (aclMap.size() > 0) { return aclMap.get(id); } } try (AutoLock l = lock.lockForWrite()) { crud.reloadAll(); return aclMap.get(id); } catch (IOException e) { throw new RuntimeException("Can not get ACL record from cache.", e); } }
@Override public void reloadAll() throws IOException { logger.debug("Reloading execute_output from " + ResourceStore.EXECUTE_OUTPUT_RESOURCE_ROOT); executableOutputDigestMap.clear(); NavigableSet<String> paths = store.listResources(ResourceStore.EXECUTE_OUTPUT_RESOURCE_ROOT); if (paths != null) { for (String path : paths) { if (!isTaskExecutableOutput(resourceName(path))) reloadAt(path); } logger.debug("Loaded {} execute_output digest(s) out of {} resource", executableOutputDigestMap.size(), paths.size()); } }
public void removeCubeLocal(String cubeName) { try (AutoLock lock = cubeMapLock.lockForWrite()) { CubeInstance cube = cubeMap.get(cubeName); if (cube != null) { cubeMap.removeLocal(cubeName); for (CubeSegment segment : cube.getSegments()) { usedStorageLocation.remove(segment.getUuid()); } Cuboid.clearCache(cube); } } }
public AclService() throws IOException { KylinConfig config = KylinConfig.getInstanceFromEnv(); ResourceStore aclStore = ResourceStore.getStore(config); this.aclMap = new CaseInsensitiveStringCache<>(config, "acl"); this.crud = new CachedCrudAssist<AclRecord>(aclStore, "/acl", "", AclRecord.class, aclMap, true) { @Override protected AclRecord initEntityAfterReload(AclRecord acl, String resourceName) { acl.init(null, aclPermissionFactory, permissionGrantingStrategy); return acl; } }; crud.reloadAll(); }
public boolean exists(String username) { try (AutoReadWriteLock.AutoLock l = lock.lockForRead()) { return userMap.containsKey(username); } } }
/** * Make sure the returned table desc is project-specific. * * All locks on srcTableMapLock are WRITE LOCKS because of this method!! */ private TableDesc getProjectSpecificTableDesc(String fullTableName, String prj) { String key = mapKey(fullTableName, prj); TableDesc result = srcTableMap.get(key); if (result == null) { try (AutoLock lock = srcTableMapLock.lockForWrite()) { result = srcTableMap.get(mapKey(fullTableName, null)); if (result != null) { result = new TableDesc(result);// deep copy of global tabledesc result.setLastModified(0); result.setProject(prj); result.setBorrowedFromGlobal(true); srcTableMap.putLocal(key, result); } } } return result; }
@Override public ExecutableOutputPO reloadAt(String path) { try { ExecutableOutputPO executableOutputPO = readJobOutputResource(path); if (executableOutputPO == null) { logger.warn("No job output found at {}, returning null", path); executableOutputDigestMap.removeLocal(resourceName(path)); return null; } // create a digest ExecutableOutputPO digestExecutableOutputPO = new ExecutableOutputPO(); digestExecutableOutputPO.setUuid(executableOutputPO.getUuid()); digestExecutableOutputPO.setLastModified(executableOutputPO.getLastModified()); digestExecutableOutputPO.setStatus(executableOutputPO.getStatus()); executableOutputDigestMap.putLocal(resourceName(path), digestExecutableOutputPO); return digestExecutableOutputPO; } catch (Exception e) { throw new IllegalStateException("Error loading execute at " + path, e); } }
public List<String> getJobIdsInCache() { Set<String> idSet = executableDigestMap.keySet(); return Lists.newArrayList(idSet); }
@Override public void onClearAll(Broadcaster broadcaster) throws IOException { try (AutoLock l = lock.lockForWrite()) { aclMap.clear(); } } }
public KylinUserManager(KylinConfig config) throws IOException { logger.info("Initializing KylinUserManager with config " + config); this.config = config; this.userMap = new CaseInsensitiveStringCache<>(config, "user"); this.crud = new CachedCrudAssist<ManagedUser>(getStore(), USER_ROOT, "", ManagedUser.class, userMap, false) { @Override protected ManagedUser initEntityAfterReload(ManagedUser user, String resourceName) { return user; } }; crud.reloadAll(); Broadcaster.getInstance(config).registerListener(new ManagedUserSyncListener(), "user"); }
/** * the project-specific table desc will be expand by computed columns from the projects' models * when the projects' model list changed, project-specific table should be reset and get expanded * again */ public void resetProjectSpecificTableDesc(String prj) throws IOException { // avoid cyclic locks ProjectInstance project = ProjectManager.getInstance(config).getProject(prj); try (AutoLock lock = srcTableMapLock.lockForWrite()) { for (String tableName : project.getTables()) { String tableIdentity = getTableIdentity(tableName); String key = mapKey(tableIdentity, prj); TableDesc originTableDesc = srcTableMap.get(key); if (originTableDesc == null) { continue; } if (originTableDesc.isBorrowedFromGlobal()) { srcTableMap.removeLocal(key);//delete it so that getProjectSpecificTableDesc will create again } else { srcTableCrud.reload(key); } } } }
public DataModelDesc updateDataModelDesc(DataModelDesc desc) throws IOException { try (AutoLock lock = modelMapLock.lockForWrite()) { String name = desc.getName(); if (!dataModelDescMap.containsKey(name)) { throw new IllegalArgumentException("DataModelDesc '" + name + "' does not exist."); } return saveDataModelDesc(desc); } }
public TableExtDesc getTableExt(TableDesc t) { try (AutoLock lock = srcExtMapLock.lockForRead()) { TableExtDesc result = srcExtMap.get(mapKey(t.getIdentity(), t.getProject())); if (null == result) { //TODO: notice the table ext is not project-specific, seems not necessary at all result = srcExtMap.get(mapKey(t.getIdentity(), null)); } // avoid returning null, since the TableDesc exists if (null == result) { result = new TableExtDesc(); result.setIdentity(t.getIdentity()); result.setUuid(RandomUtil.randomUUID().toString()); result.setLastModified(0); result.init(t.getProject()); srcExtMap.putLocal(mapKey(t.getIdentity(), t.getProject()), result); } return result; } }
@Override public ExecutablePO reloadAt(String path) { try { ExecutablePO executablePO = readJobResource(path); if (executablePO == null) { logger.warn("No job found at {}, returning null", path); executableDigestMap.removeLocal(resourceName(path)); return null; } // create a digest ExecutablePO digestExecutablePO = new ExecutablePO(); digestExecutablePO.setUuid(executablePO.getUuid()); digestExecutablePO.setName(executablePO.getName()); digestExecutablePO.setLastModified(executablePO.getLastModified()); digestExecutablePO.setType(executablePO.getType()); digestExecutablePO.setParams(executablePO.getParams()); executableDigestMap.putLocal(resourceName(path), digestExecutablePO); return digestExecutablePO; } catch (Exception e) { throw new IllegalStateException("Error loading execute at " + path, e); } }
@Override public void reloadAll() throws IOException { logger.debug("Reloading execute_output from " + ResourceStore.EXECUTE_OUTPUT_RESOURCE_ROOT); executableOutputDigestMap.clear(); NavigableSet<String> paths = store.listResources(ResourceStore.EXECUTE_OUTPUT_RESOURCE_ROOT); if (paths != null) { for (String path : paths) { if (!isTaskExecutableOutput(resourceName(path))) reloadAt(path); } logger.debug("Loaded {} execute_output digest(s) out of {} resource", executableOutputDigestMap.size(), paths.size()); } }
List<String> reloadAllTempStatement() throws IOException { try (AutoLock l = lock.lockForWrite()) { crud.reloadAll(); return new ArrayList<>(tmpStatMap.keySet()); } }
public TableACLManager(KylinConfig config) throws IOException { logger.info("Initializing TableACLManager with config " + config); this.config = config; this.tableACLMap = new CaseInsensitiveStringCache<>(config, "table_acl"); this.crud = new CachedCrudAssist<TableACL>(getStore(), "/table_acl", "", TableACL.class, tableACLMap, true) { @Override protected TableACL initEntityAfterReload(TableACL acl, String resourceName) { acl.init(resourceName); return acl; } }; crud.reloadAll(); Broadcaster.getInstance(config).registerListener(new TableACLSyncListener(), "table_acl"); }