Java IRODSFile类代码示例

import org.irods.jargon.core.pub.io.IRODSFile; //导入依赖的package包/类
@Override
public AttributedList<Path> list(final Path directory, final ListProgressListener listener) throws BackgroundException {
    try {
        final AttributedList<Path> children = new AttributedList<Path>();
        final IRODSFileSystemAO fs = session.getClient();
        final IRODSFile f = fs.getIRODSFileFactory().instanceIRODSFile(directory.getAbsolute());
        if(!f.exists()) {
            throw new NotfoundException(directory.getAbsolute());
        }
        for(File file : fs.getListInDirWithFileFilter(f, TrueFileFilter.TRUE)) {
            final String normalized = PathNormalizer.normalize(file.getAbsolutePath(), true);
            if(StringUtils.equals(normalized, directory.getAbsolute())) {
                continue;
            }
            final PathAttributes attributes = new PathAttributes();
            final ObjStat stats = fs.getObjStat(file.getAbsolutePath());
            attributes.setModificationDate(stats.getModifiedAt().getTime());
            attributes.setCreationDate(stats.getCreatedAt().getTime());
            attributes.setSize(stats.getObjSize());
            attributes.setChecksum(Checksum.parse(Hex.encodeHexString(Base64.decodeBase64(stats.getChecksum()))));
            attributes.setOwner(stats.getOwnerName());
            attributes.setGroup(stats.getOwnerZone());
            children.add(new Path(directory, PathNormalizer.name(normalized),
                    file.isDirectory() ? EnumSet.of(Path.Type.directory) : EnumSet.of(Path.Type.file),
                    attributes));
            listener.chunk(directory, children);
        }
        return children;
    }
    catch(JargonException e) {
        throw new IRODSExceptionMappingService().map("Listing directory {0} failed", e, directory);
    }
}
 

import org.irods.jargon.core.pub.io.IRODSFile; //导入依赖的package包/类
@Override
public PathAttributes find(final Path file) throws BackgroundException {
    try {
        final IRODSFileSystemAO fs = session.getClient();
        final IRODSFile f = fs.getIRODSFileFactory().instanceIRODSFile(file.getAbsolute());
        if(!f.exists()) {
            throw new NotfoundException(file.getAbsolute());
        }
        final PathAttributes attributes = new PathAttributes();
        final ObjStat stats = fs.getObjStat(f.getAbsolutePath());
        attributes.setModificationDate(stats.getModifiedAt().getTime());
        attributes.setCreationDate(stats.getCreatedAt().getTime());
        attributes.setSize(stats.getObjSize());
        attributes.setChecksum(Checksum.parse(Hex.encodeHexString(Base64.decodeBase64(stats.getChecksum()))));
        attributes.setOwner(stats.getOwnerName());
        attributes.setGroup(stats.getOwnerZone());
        return attributes;
    }
    catch(JargonException e) {
        throw new IRODSExceptionMappingService().map("Failure to read attributes of {0}", e, file);
    }
}
 

import org.irods.jargon.core.pub.io.IRODSFile; //导入依赖的package包/类
@Override
public Path move(final Path file, final Path renamed, final TransferStatus status, final Delete.Callback callback, final ConnectionCallback connectionCallback) throws BackgroundException {
    try {
        final IRODSFileSystemAO fs = session.getClient();
        final IRODSFile s = fs.getIRODSFileFactory().instanceIRODSFile(file.getAbsolute());
        if(!s.exists()) {
            throw new NotfoundException(String.format("%s doesn't exist", file.getAbsolute()));
        }
        if(status.isExists()) {
            delete.delete(Collections.singletonList(renamed), connectionCallback, callback);
        }
        final IRODSFile d = fs.getIRODSFileFactory().instanceIRODSFile(renamed.getAbsolute());
        s.renameTo(d);
        return renamed;
    }
    catch(JargonException e) {
        throw new IRODSExceptionMappingService().map("Cannot rename {0}", e, file);
    }
}
 

import org.irods.jargon.core.pub.io.IRODSFile; //导入依赖的package包/类
protected void retrieveFile(String remoteFileName, String localDirPath) 
		throws ReplicationServiceException {
	try {
		if(overrideJargonProperties!=null) {
			irodsFileSystem.getIrodsSession().setJargonProperties(overrideJargonProperties);
		}		
		File localFile = new File(localDirPath);

		IRODSFileFactory irodsFileFactory = irodsFileSystem .getIRODSFileFactory(irodsAccount);

		IRODSFile remoteFile = irodsFileFactory.instanceIRODSFile(remoteFileName);

		DataTransferOperations dataTransferOperations = irodsFileSystem
				.getIRODSAccessObjectFactory()
				.getDataTransferOperations(irodsAccount);

		dataTransferOperations.getOperation(remoteFile.getAbsolutePath(), localFile.getAbsolutePath(), "", null, null);    	
	} catch (JargonException e) {
		throw new ReplicationServiceException(e);
	}
}
 

import org.irods.jargon.core.pub.io.IRODSFile; //导入依赖的package包/类
Document retrieveDocumentForId(final String id)
		throws FileNotFoundException, JargonException {
	log.info("retrieveDocumentForId()");
	if (id == null || id.isEmpty()) {
		throw new IllegalArgumentException("null or empty id");
	}

	log.info("id:{}", id);

	log.info("get irodsFileFactory...");
	IRODSFile docFile = connectorContext.getIrodsAccessObjectFactory()
			.getIRODSFileFactory(irodsAccount).instanceIRODSFile(id);

	if (!docFile.exists()) {
		throw new FileNotFoundException("file not found");
	}

	if (docFile.isDirectory()) {
		return retriveCollectionForId(docFile);
	} else {
		return retriveDataObjectForId(docFile);
	}

}
 

import org.irods.jargon.core.pub.io.IRODSFile; //导入依赖的package包/类
@Override
public void delete(final List<Path> files, final PasswordCallback prompt, final Callback callback) throws BackgroundException {
    final List<Path> deleted = new ArrayList<Path>();
    for(Path file : files) {
        boolean skip = false;
        for(Path d : deleted) {
            if(file.isChild(d)) {
                skip = true;
                break;
            }
        }
        if(skip) {
            continue;
        }
        deleted.add(file);
        callback.delete(file);
        try {
            final IRODSFile f = session.getClient().getIRODSFileFactory().instanceIRODSFile(file.getAbsolute());
            if(!f.exists()) {
                throw new NotfoundException(String.format("%s doesn't exist", file.getAbsolute()));
            }
            if(f.isFile()) {
                session.getClient().fileDeleteForce(f);
            }
            else if(f.isDirectory()) {
                session.getClient().directoryDeleteForce(f);
            }
        }
        catch(JargonException e) {
            throw new IRODSExceptionMappingService().map("Cannot delete {0}", e, file);
        }
    }
}
 

import org.irods.jargon.core.pub.io.IRODSFile; //导入依赖的package包/类
@Override
public boolean find(final Path file) throws BackgroundException {
    if(file.isRoot()) {
        return true;
    }
    try {
        final IRODSFileSystemAO fs = session.getClient();
        final IRODSFile f = fs.getIRODSFileFactory().instanceIRODSFile(file.getAbsolute());
        return fs.isFileExists(f);
    }
    catch(JargonException e) {
        throw new IRODSExceptionMappingService().map("Failure to read attributes of {0}", e, file);
    }
}
 

import org.irods.jargon.core.pub.io.IRODSFile; //导入依赖的package包/类
@Override
public Path mkdir(final Path folder, final String region, final TransferStatus status) throws BackgroundException {
    try {
        final IRODSFileSystemAO fs = session.getClient();
        final IRODSFile f = fs.getIRODSFileFactory().instanceIRODSFile(folder.getAbsolute());
        fs.mkdir(f, false);
    }
    catch(JargonException e) {
        throw new IRODSExceptionMappingService().map("Cannot create folder {0}", e, folder);
    }
    return folder;
}
 

import org.irods.jargon.core.pub.io.IRODSFile; //导入依赖的package包/类
@Override
public void download(final Path file, final Local local, final BandwidthThrottle throttle,
                     final StreamListener listener, final TransferStatus status,
                     final ConnectionCallback connectionCallback, final PasswordCallback passwordCallback) throws BackgroundException {
    try {
        final IRODSFileSystemAO fs = session.getClient();
        final IRODSFile f = fs.getIRODSFileFactory().instanceIRODSFile(file.getAbsolute());
        if(f.exists()) {
            final TransferControlBlock block = DefaultTransferControlBlock.instance(StringUtils.EMPTY,
                    preferences.getInteger("connection.retry"));
            final TransferOptions options = new DefaultTransferOptionsConfigurer().configure(new TransferOptions());
            options.setUseParallelTransfer(session.getHost().getTransferType().equals(Host.TransferType.concurrent));
            block.setTransferOptions(options);
            final DataTransferOperations transfer = fs.getIRODSAccessObjectFactory()
                    .getDataTransferOperations(fs.getIRODSAccount());
            transfer.getOperation(f, new File(local.getAbsolute()),
                    new DefaultTransferStatusCallbackListener(status, listener, block),
                    block);
        }
        else {
            throw new NotfoundException(file.getAbsolute());
        }
    }
    catch(JargonException e) {
        throw new IRODSExceptionMappingService().map("Download {0} failed", e, file);
    }
}
 

import org.irods.jargon.core.pub.io.IRODSFile; //导入依赖的package包/类
public void create_user_folder(IRODSAccount account, String sourceFilePath, String irodsPath,
        String targetFileName, String userName, String datasetURI, String creationDate, String datasetName,
        String datasetType)
        throws JargonException {
    logger.debug("Importing to IRODS-Server[\n\tiRODS account: " + account.toString()
            + "\tSourceFilePath: " + sourceFilePath
            + "\tiRODSPath: " + irodsPath
            + "\tTargetFileName: " + targetFileName
            + "\tUsername: " + userName
            + "\tDatasetURI: " + datasetURI
            + "\tDatasetName: " + datasetName
            + "\tCreationDate: " + creationDate);

    IRODSFileSystem irodsFileSystem = IRODSFileSystem.instance();

    DataTransferOperations dataTransferOperations = irodsFileSystem.getIRODSAccessObjectFactory().getDataTransferOperations(account);

    File sourceFile = new File(sourceFilePath);

    IRODSFileFactory irodsFileFactory = irodsFileSystem.getIRODSFileFactory(account);

    //newFileName = "/tempZone/home/rods/"+newFileName;
    String userFolderPath = irodsPath + "/" + userName + "/";

    IRODSFile targetFileFolder = irodsFileFactory.instanceIRODSFile(userFolderPath);

    targetFileFolder.mkdir();

    String targetFilePath = userFolderPath + "/" + datasetName + "/";

    IRODSFile targetFile = irodsFileFactory.instanceIRODSFile(targetFilePath);

    targetFile.mkdir();

}
 

import org.irods.jargon.core.pub.io.IRODSFile; //导入依赖的package包/类
public IrodsObject getObject(String irodsPath) throws IrodsException {
	while (irodsPath.endsWith("/")) {
		irodsPath = irodsPath.substring(0, irodsPath.length() - 1);
	}
	try {
		IRODSFile irodsFile = irodsFileFactory.instanceIRODSFile(irodsPath);
		return new JargonObject(this, irodsFile);
	} catch (Exception ex) {
		throw new IrodsException(ex);
	}
}
 

import org.irods.jargon.core.pub.io.IRODSFile; //导入依赖的package包/类
public JargonCollection getParentCollection() throws IrodsException {
	IRODSFile p;
	try {
		if (irodsFile.getParent() == null || irodsFile.getParent().isEmpty()) {
			return null;
		}
		p = conn.irodsFileFactory.instanceIRODSFile(irodsFile.getParent());
	} catch (JargonException ex) {
		throw new IrodsException(ex);
	}
	return new JargonCollection(conn, p);
}
 

import org.irods.jargon.core.pub.io.IRODSFile; //导入依赖的package包/类
public Collection<IrodsCollection> listCollections() throws IrodsException {
	List<IrodsCollection> l = new ArrayList<IrodsCollection>();
	for (File f : irodsFile.listFiles()) {
		if (f instanceof IRODSFile && f.isDirectory()) {
			l.add(new JargonCollection(conn, (IRODSFile) f));
		}
	}
	return l;
}
 

import org.irods.jargon.core.pub.io.IRODSFile; //导入依赖的package包/类
public Collection<IrodsFile> listFiles() throws IrodsException {
	List<IrodsFile> l = new ArrayList<IrodsFile>();
	for (File f : irodsFile.listFiles()) {
		if (f instanceof IRODSFile && f.isFile()) {
			l.add(new JargonFile(conn, (IRODSFile) f));
		}
	}
	return l;
}
 

import org.irods.jargon.core.pub.io.IRODSFile; //导入依赖的package包/类
@Override
public Checksum upload(final Path file, final Local local, final BandwidthThrottle throttle,
                       final StreamListener listener, final TransferStatus status,
                       final ConnectionCallback callback) throws BackgroundException {
    try {
        final IRODSFileSystemAO fs = session.getClient();
        final IRODSFile f = fs.getIRODSFileFactory().instanceIRODSFile(file.getAbsolute());
        final TransferControlBlock block = DefaultTransferControlBlock.instance(StringUtils.EMPTY,
                preferences.getInteger("connection.retry"));
        final TransferOptions options = new DefaultTransferOptionsConfigurer().configure(new TransferOptions());
        options.setUseParallelTransfer(session.getHost().getTransferType().equals(Host.TransferType.concurrent));
        block.setTransferOptions(options);
        final DataTransferOperations transfer = fs.getIRODSAccessObjectFactory().getDataTransferOperations(fs.getIRODSAccount());
        transfer.putOperation(new File(local.getAbsolute()), f, new DefaultTransferStatusCallbackListener(
                status, listener, block
        ), block);
        if(status.isComplete()) {
            final DataObjectChecksumUtilitiesAO checksum = fs
                    .getIRODSAccessObjectFactory()
                    .getDataObjectChecksumUtilitiesAO(fs.getIRODSAccount());
            final ChecksumValue value = checksum.computeChecksumOnDataObject(f);
            final Checksum fingerprint = Checksum.parse(value.getChecksumStringValue());
            if(null == fingerprint) {
                log.warn(String.format("Unsupported checksum algorithm %s", value.getChecksumEncoding()));
            }
            else {
                if(file.getType().contains(Path.Type.encrypted)) {
                    log.warn(String.format("Skip checksum verification for %s with client side encryption enabled", file));
                }
                else {
                    final Checksum expected = ChecksumComputeFactory.get(fingerprint.algorithm).compute(local.getInputStream(), status);
                    if(!expected.equals(fingerprint)) {
                        throw new ChecksumException(MessageFormat.format(LocaleFactory.localizedString("Upload {0} failed", "Error"), file.getName()),
                                MessageFormat.format("Mismatch between {0} hash {1} of uploaded data and ETag {2} returned by the server",
                                        fingerprint.algorithm.toString(), expected, fingerprint.hash));
                    }
                }
            }
            return fingerprint;
        }
        return null;
    }
    catch(JargonException e) {
        throw new IRODSExceptionMappingService().map(e);
    }
}