@Override public boolean hasAccess( ObjectId id, RepositoryFilePermission perm ) throws KettleException { RepositoryFile repositoryFile = pur.getFileById( id.getId() ); return pur.hasAccess( repositoryFile.getPath(), EnumSet.of( perm ) ); }
protected List<RepositoryFile> getAllFilesOfType( final ObjectId dirId, final List<RepositoryObjectType> objectTypes, final boolean includeDeleted ) throws KettleException { List<RepositoryFile> allChildren = new ArrayList<RepositoryFile>(); List<RepositoryFile> children = getAllFilesOfType( dirId, objectTypes ); allChildren.addAll( children ); if ( includeDeleted ) { String dirPath = null; if ( dirId != null ) { // derive path using id readWriteLock.readLock().lock(); try { dirPath = pur.getFileById( dirId.getId() ).getPath(); } finally { readWriteLock.readLock().unlock(); } } List<RepositoryFile> deletedChildren = getAllDeletedFilesOfType( dirPath, objectTypes ); allChildren.addAll( deletedChildren ); Collections.sort( allChildren ); } return allChildren; }
protected RepositoryLock getLockById( final ObjectId id ) throws KettleException { try { RepositoryFile file = pur.getFileById( id.getId() ); return getLock( file ); } catch ( Exception e ) { throw new KettleException( "Unable to get lock for object with id [" + id + "]", e ); } }
protected RepositoryFile validateElementTypeRepositoryFolder( String namespace, IMetaStoreElementType elementType ) throws MetaStoreException { // The element type needs to be known in this repository, we need to have a match by ID // RepositoryFile elementTypeFolder = pur.getFileById( elementType.getId() ); if ( elementTypeFolder == null ) { StringBuilder builder = new StringBuilder(); builder.append( namespacesFolder.getPath() ).append( Const.CR ); String available = getMetaStoreFolders( builder, namespacesFolder, 0 ); throw new MetaStoreException( "The element type with name '" + elementType.getName() + " doesn't exist in namespace '" + namespace + "'." + Const.CR + "Available nodes:" + Const.CR + available ); } return elementTypeFolder; }
@Override public PartitionSchema loadPartitionSchema( ObjectId partitionSchemaId, String versionId ) throws KettleException { readWriteLock.readLock().lock(); try { NodeRepositoryFileData data = pur.getDataAtVersionForRead( partitionSchemaId.getId(), versionId, NodeRepositoryFileData.class ); RepositoryFile file = null; if ( versionId != null ) { file = pur.getFileAtVersion( partitionSchemaId.getId(), versionId ); } else { file = pur.getFileById( partitionSchemaId.getId() ); } return partitionSchemaTransformer.assemble( file, data, pur.getVersionSummary( partitionSchemaId.getId(), versionId ) ); } catch ( Exception e ) { throw new KettleException( "Unable to load partition schema with id [" + partitionSchemaId + "]", e ); } finally { readWriteLock.readLock().unlock(); } }
if ( fileId != null ) { Repository repository = connectToRepository(); RepositoryFile file = unifiedRepository.getFileById( fileId ); if ( file != null ) { try {
@Override public SlaveServer loadSlaveServer( ObjectId idSlaveServer, String versionId ) throws KettleException { readWriteLock.readLock().lock(); try { NodeRepositoryFileData data = pur.getDataAtVersionForRead( idSlaveServer.getId(), versionId, NodeRepositoryFileData.class ); RepositoryFile file = null; if ( versionId != null ) { file = pur.getFileAtVersion( idSlaveServer.getId(), versionId ); } else { file = pur.getFileById( idSlaveServer.getId() ); } return slaveTransformer.assemble( file, data, pur.getVersionSummary( idSlaveServer.getId(), versionId ) ); } catch ( Exception e ) { throw new KettleException( "Unable to load slave server with id [" + idSlaveServer + "]", e ); } finally { readWriteLock.readLock().unlock(); } }
@Override public DatabaseMeta loadDatabaseMeta( final ObjectId databaseId, final String versionId ) throws KettleException { readWriteLock.readLock().lock(); try { NodeRepositoryFileData data = pur.getDataAtVersionForRead( databaseId.getId(), versionId, NodeRepositoryFileData.class ); RepositoryFile file = null; if ( versionId != null ) { file = pur.getFileAtVersion( databaseId.getId(), versionId ); } else { file = pur.getFileById( databaseId.getId() ); } return databaseMetaTransformer.assemble( file, data, pur.getVersionSummary( databaseId.getId(), versionId ) ); } catch ( Exception e ) { throw new KettleException( "Unable to load database with id [" + databaseId + "]", e ); } finally { readWriteLock.readLock().unlock(); } }
@Override public ClusterSchema loadClusterSchema( ObjectId idClusterSchema, List<SlaveServer> slaveServers, String versionId ) throws KettleException { readWriteLock.readLock().lock(); try { // We dont need to use slaveServer variable as the dataNoteToElement method finds the server from the repository NodeRepositoryFileData data = pur.getDataAtVersionForRead( idClusterSchema.getId(), versionId, NodeRepositoryFileData.class ); RepositoryFile file = null; if ( versionId != null ) { file = pur.getFileAtVersion( idClusterSchema.getId(), versionId ); } else { file = pur.getFileById( idClusterSchema.getId() ); } return clusterTransformer.assemble( file, data, pur.getVersionSummary( idClusterSchema.getId(), versionId ) ); } catch ( Exception e ) { throw new KettleException( "Unable to load cluster schema with id [" + idClusterSchema + "]", e ); } finally { readWriteLock.readLock().unlock(); } }
@Override public RepositoryDirectory findDirectory( ObjectId id_directory ) { RepositoryFile file = repository.getFileById( id_directory.getId() ); if ( file == null || !file.isFolder() ) { return null; } if ( isRoot() && RepositoryDirectory.DIRECTORY_SEPARATOR.equals( file.getPath() ) ) { return this; } // Verifies if this is the parent directory of file and if so passes this as parent argument String parentPath = getParentPath( file.getPath() ); if ( self.getPath().endsWith( RepositoryDirectory.DIRECTORY_SEPARATOR ) ) { if ( parentPath.equals( self.getPath().substring( 0, self.getPath().length() - 1 ) ) ) { return new LazyUnifiedRepositoryDirectory( file, this, repository, registry, showHidden ); } } else { if ( parentPath.equals( self.getPath() ) ) { return new LazyUnifiedRepositoryDirectory( file, this, repository, registry, showHidden ); } } return new LazyUnifiedRepositoryDirectory( file, findDirectory( parentPath ), repository, registry, showHidden ); }
try { RepositoryFile dirFile; dirFile = pur.getFileById( dirId.getId() ); if ( dirId != null ) { dirPath = pur.getFileById( dirId.getId() ).getPath();
@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(); } }
try { try { repositoryFile = pur.getFileById( objectId.getId() ); } catch ( Exception e ) {
folder = pur.getFileById( dirId.getId() );
@Override public synchronized void updateElement( String namespace, IMetaStoreElementType elementType, String elementId, IMetaStoreElement element ) throws MetaStoreException { // verify that the element type belongs to this meta store // if ( elementType.getMetaStoreName() == null || !elementType.getName().equals( getName() ) ) { String elementTypeName = elementType.getName(); elementType = getElementTypeByName( namespace, elementTypeName ); if ( elementType == null ) { throw new MetaStoreException( "The element type '" + elementTypeName + "' could not be found in the meta store in which you are updating." ); } } RepositoryFile existingFile = pur.getFileById( elementId ); if ( existingFile == null ) { throw new MetaStoreException( "The element to update with id " + elementId + " could not be found in the store" ); } DataNode elementDataNode = new DataNode( PurRepository.checkAndSanitize( element.getName() ) ); elementToDataNode( element, elementDataNode ); RepositoryFile updatedFile = pur.updateFile( existingFile, new NodeRepositoryFileData( elementDataNode ), null ); element.setId( updatedFile.getId().toString() ); }
@Override public IMetaStoreElementType getElementType( String namespace, String elementTypeId ) throws MetaStoreException { RepositoryFile elementTypeFolder = pur.getFileById( elementTypeId ); if ( elementTypeFolder == null ) { return null; } IMetaStoreElementType elementType = newElementType( namespace ); elementType.setId( elementTypeFolder.getId().toString() ); elementType.setName( elementTypeFolder.getName() ); RepositoryFile detailsFile = findChildByName( elementTypeFolder.getId(), ELEMENT_TYPE_DETAILS_FILENAME, true ); if ( detailsFile != null ) { NodeRepositoryFileData data = pur.getDataForRead( detailsFile.getId(), NodeRepositoryFileData.class ); DataProperty property = data.getNode().getProperty( "element_type_description" ); if ( property != null ) { elementType.setDescription( property.getString() ); } } return elementType; }
public void createElement( String namespace, IMetaStoreElementType elementType, IMetaStoreElement element ) throws MetaStoreException { RepositoryFile elementTypeFolder = validateElementTypeRepositoryFolder( namespace, elementType ); RepositoryFile elementFile = new RepositoryFile.Builder( PurRepository.checkAndSanitize( element.getName() ) ).title( element.getName() ) .versioned( false ).build(); DataNode elementDataNode = new DataNode( PurRepository.checkAndSanitize( element.getName() ) ); elementToDataNode( element, elementDataNode ); RepositoryFile createdFile = pur.createFile( elementTypeFolder.getId(), elementFile, new NodeRepositoryFileData( elementDataNode ), null ); element.setId( createdFile.getId().toString() ); // Verify existence. if ( pur.getFileById( createdFile.getId() ) == null ) { throw new RuntimeException( "Unable to verify creation of element '" + element.getName() + "' in folder: " + elementTypeFolder.getPath() ); } }
file = pur.getFileAtVersion( idJob.getId(), versionLabel ); } else { file = pur.getFileById( idJob.getId() );
file = pur.getFileAtVersion( idTransformation.getId(), versionLabel ); } else { file = pur.getFileById( idTransformation.getId() );
try { if ( isUpdate ) { file = pur.getFileById( element.getObjectId().getId() );