private Serializable getSlaveServerParentFolderId() { if ( cachedSlaveServerParentFolderId == null ) { readWriteLock.readLock().lock(); RepositoryFile f; try { f = pur.getFile( getSlaveServerParentFolderPath() ); } finally { readWriteLock.readLock().unlock(); } cachedSlaveServerParentFolderId = f.getId(); } return cachedSlaveServerParentFolderId; }
ObjectRevision revision = null; try { file = pur.getFile( absPath ); if ( versionId != null ) {
@Override public void deleteRepositoryDirectory( final RepositoryDirectoryInterface dir, final boolean deleteHomeDirectories ) throws KettleException { readWriteLock.writeLock().lock(); try { // Fetch the folder to be deleted RepositoryFile folder; RepositoryFile homeFolder; folder = pur.getFileById( dir.getObjectId().getId() ); // Fetch the user's home directory homeFolder = pur.getFile( ClientRepositoryPaths.getUserHomeFolderPath( user.getLogin() ) ); // Make sure the user is not trying to delete their own home directory if ( isSameOrAncestorFolder( folder, homeFolder ) ) { // Then throw an exception that the user cannot delete their own home directory throw new KettleException( "You are not allowed to delete your home folder." ); } if ( !deleteHomeDirectories && isUserHomeDirectory( folder ) ) { throw new RepositoryObjectAccessException( "Cannot delete another users home directory", RepositoryObjectAccessException.AccessExceptionType.USER_HOME_DIR ); } pur.deleteFile( dir.getObjectId().getId(), null ); rootRef.clearRef(); } catch ( Exception e ) { throw new KettleException( "Unable to delete directory with path [" + getPath( null, dir, null ) + "]", e ); } finally { readWriteLock.writeLock().unlock(); } }
Serializable getDatabaseMetaParentFolderId() { if ( cachedDatabaseMetaParentFolderId == null ) { readWriteLock.readLock().lock(); RepositoryFile f; try { f = pur.getFile( getDatabaseMetaParentFolderPath() ); } finally { readWriteLock.readLock().unlock(); } cachedDatabaseMetaParentFolderId = f.getId(); } return cachedDatabaseMetaParentFolderId; }
RepositoryFile folder; homeFolder = pur.getFile( ClientRepositoryPaths.getUserHomeFolderPath( user.getLogin() ) ); folder = pur.getFileById( dirId.getId() );
file = pur.getFile( absPath ); if ( versionId != null ) {
private Serializable getClusterSchemaParentFolderId() { if ( cachedClusterSchemaParentFolderId == null ) { readWriteLock.readLock().lock(); RepositoryFile f; try { f = pur.getFile( getClusterSchemaParentFolderPath() ); } finally { readWriteLock.readLock().unlock(); } cachedClusterSchemaParentFolderId = f.getId(); } return cachedClusterSchemaParentFolderId; }
RepositoryFile fileFromDestination; fileFromDestination = pur.getFile( absPath );
private Serializable getPartitionSchemaParentFolderId() { if ( cachedPartitionSchemaParentFolderId == null ) { readWriteLock.readLock().lock(); RepositoryFile f; try { f = pur.getFile( getPartitionSchemaParentFolderPath() ); } finally { readWriteLock.readLock().unlock(); } cachedPartitionSchemaParentFolderId = f.getId(); } return cachedPartitionSchemaParentFolderId; }
@Override public boolean hasUserParameters( String kettleFilePath ) { if ( !StringUtils.isEmpty( kettleFilePath ) ) { RepositoryFile file = unifiedRepository.getFile( kettleFilePath ); if ( file != null ) { try { return hasUserParameters( getMeta( file ) ); } catch ( KettleException e ) { log.error( e ); } } } return false; }
@Override public boolean exists( final String name, final RepositoryDirectoryInterface repositoryDirectory, final RepositoryObjectType objectType ) throws KettleException { try { String absPath = getPath( name, repositoryDirectory, objectType ); readWriteLock.readLock().lock(); boolean result; try { result = pur.getFile( absPath ) != null; } finally { readWriteLock.readLock().unlock(); } return result; } catch ( Exception e ) { throw new KettleException( "Unable to verify if the repository element [" + name + "] exists in ", e ); } }
public PurRepositoryMetaStore( PurRepository repository ) throws KettleException { this.repository = repository; this.pur = repository.getUnderlyingRepository(); namespacesFolder = pur.getFile( METASTORE_FOLDER_PATH ); if ( namespacesFolder == null ) { throw new KettleException( METASTORE_FOLDER_PATH + " folder is not available" ); } }
@Override public String[] getUserParameters( String kettleFilePath ) { List<String> userParams = new ArrayList<String>(); if ( !StringUtils.isEmpty( kettleFilePath ) ) { RepositoryFile file = unifiedRepository.getFile( kettleFilePath ); if ( file != null ) { try { NamedParams np = getMeta( file ); if ( !isEmpty( np = filterUserParameters( np ) ) ) { return np.listParameters(); } } catch ( KettleException e ) { log.error( e ); } } } return userParams.toArray( new String[] {} ); }
RepositoryFile homeRootFolder; try { homeRootFolder = pur.getFile( ClientRepositoryPaths.getHomeFolderPath() ); } finally { readWriteLock.readLock().unlock();
@Override public void deleteDatabaseMeta( final String databaseName ) throws KettleException { RepositoryFile fileToDelete = null; ObjectId idDatabase = null; try { readWriteLock.writeLock().lock(); try { fileToDelete = pur.getFile( getPath( databaseName, null, RepositoryObjectType.DATABASE ) ); idDatabase = new StringObjectId( fileToDelete.getId().toString() ); permanentlyDeleteSharedObject( idDatabase ); removeFromSharedObjectCache( RepositoryObjectType.DATABASE, idDatabase ); } finally { readWriteLock.writeLock().unlock(); } } catch ( Exception e ) { throw new KettleException( "Unable to delete database with name [" + databaseName + "]", e ); } }
@Deprecated @Override public RepositoryDirectoryInterface loadRepositoryDirectoryTree( boolean eager ) throws KettleException { // this method forces a reload of the repository directory tree structure // a new rootRef will be obtained - this is a SoftReference which will be used // by any calls to getRootDir() RepositoryDirectoryInterface rootDir; if ( eager ) { RepositoryFileTree rootFileTree = loadRepositoryFileTree( ClientRepositoryPaths.getRootFolderPath() ); rootDir = initRepositoryDirectoryTree( rootFileTree ); } else { readWriteLock.readLock().lock(); RepositoryFile root; try { root = pur.getFile( "/" ); } finally { readWriteLock.readLock().unlock(); } IUser user = this.getUserInfo(); boolean showHidden = user != null ? user.isAdmin() : true; rootDir = new LazyUnifiedRepositoryDirectory( root, null, pur, purRepositoryServiceRegistry, showHidden ); } rootRef.setRef( rootDir ); return rootDir; }
List<ObjectRevision> originalRevisions = null; RepositoryFile repositoryFile = repository.getFile( FileUtils.idToPath( pathId ) ); if ( repositoryFile != null ) { fileId = repositoryFile.getId();
private List<RepositoryFile> getAllURChildrenFiles() { RepositoryRequest repositoryRequest = new RepositoryRequest(); repositoryRequest.setShowHidden( showHidden ); repositoryRequest.setTypes( RepositoryRequest.FILES_TYPE_FILTER.FOLDERS ); repositoryRequest.setPath( this.self.getId().toString() ); List<RepositoryFile> children = repository.getChildren( repositoryRequest ); // Special case: /etc should not be returned from a directory listing. RepositoryFile etcFile = null; if ( this.isRoot() ) { etcFile = repository.getFile( ClientRepositoryPaths.getEtcFolderPath() ); } // Filter for Folders only doesn't appear to work Iterator<RepositoryFile> iterator = children.iterator(); while ( iterator.hasNext() ) { RepositoryFile next = iterator.next(); if ( !next.isFolder() ) { iterator.remove(); } // Special case: /etc should not be returned from a directory listing. if ( this.isRoot() && next.equals( etcFile ) ) { iterator.remove(); } } return children; }
RepositoryFile file = repository.getFile( absolutePath ); if ( file == null || !file.isFolder() ) { return null;
try { RepositoryFile file; file = pur.getFile( absPath );