public String uploadFile(
final ImportProcessPrx proc,
final String[] srcFiles,
final int index,
final ChecksumProviderFactory cpf,
TimeEstimator estimator,
final byte[] buf)
throws ServerError, IOException {
final ChecksumProvider cp =
cpf.getProvider(
ChecksumAlgorithmMapper.getChecksumType(proc.getImportSettings().checksumAlgorithm));
final File file = new File(Location.getMappedId(srcFiles[index]));
try {
return transfer.transfer(
new TransferState(file, index, srcFiles.length, proc, this, estimator, cp, buf));
} catch (Exception e) {
// Required to bump the error count
notifyObservers(
new ErrorHandler.FILE_EXCEPTION(file.getAbsolutePath(), e, srcFiles, "unknown"));
// The state that we're entering, i.e. exiting upload via error
notifyObservers(
new ImportEvent.FILE_UPLOAD_ERROR(
file.getAbsolutePath(), index, srcFiles.length, null, null, e));
if (e instanceof RuntimeException) {
throw (RuntimeException) e;
} else if (e instanceof ServerError) {
throw (ServerError) e;
} else if (e instanceof IOException) {
throw (IOException) e;
} else {
String msg = "Unexpected exception thrown!";
log.error(msg, e);
throw new RuntimeException(msg, e);
}
}
}
/**
* Provide initial configuration to the server in order to create the {@link ImportProcessPrx}
* which will manage state server-side.
*
* @param container the import container
* @return the new import process from the server
* @throws ServerError if the import process could not be created
* @throws IOException if the used files' absolute path could not be found
*/
public ImportProcessPrx createImport(final ImportContainer container)
throws ServerError, IOException {
checkManagedRepo();
String[] usedFiles = container.getUsedFiles();
File target = container.getFile();
if (log.isDebugEnabled()) {
log.debug("Main file: " + target.getAbsolutePath());
log.debug("Used files before:");
for (String f : usedFiles) {
log.debug(f);
}
}
notifyObservers(
new ImportEvent.FILESET_UPLOAD_PREPARATION(null, 0, usedFiles.length, null, null, null));
// Copied to ClientPathExclusion
// TODO: allow looser sanitization according to server configuration
final FilePathRestrictions portableRequiredRules =
FilePathRestrictionInstance.getFilePathRestrictions(
FilePathRestrictionInstance.WINDOWS_REQUIRED,
FilePathRestrictionInstance.UNIX_REQUIRED);
final ClientFilePathTransformer sanitizer =
new ClientFilePathTransformer(new MakePathComponentSafe(portableRequiredRules));
final ImportSettings settings = new ImportSettings();
final Fileset fs = new FilesetI();
container.fillData(settings, fs, sanitizer, transfer);
String caStr = container.getChecksumAlgorithm();
if (caStr != null) {
settings.checksumAlgorithm = ChecksumAlgorithmMapper.getChecksumAlgorithm(caStr);
} else {
// check if the container object has ChecksumAlgorithm
// present and pass it into the settings object
settings.checksumAlgorithm = repo.suggestChecksumAlgorithm(availableChecksumAlgorithms);
if (settings.checksumAlgorithm == null) {
throw new RuntimeException("no supported checksum algorithm negotiated with server");
}
}
return repo.importFileset(fs, settings);
}
/**
* Perform an image import uploading files if necessary.
*
* @param container The import container which houses all the configuration values and target for
* the import.
* @param index Index of the import in a set. <code>0</code> is safe if this is a singular import.
* @param numDone Number of imports completed in a set. <code>0</code> is safe if this is a
* singular import.
* @param total Total number of imports in a set. <code>1</code> is safe if this is a singular
* import.
* @return List of Pixels that have been imported.
* @throws FormatException If there is a Bio-Formats image file format error during import.
* @throws IOException If there is an I/O error.
* @throws ServerError If there is an error communicating with the OMERO server we're importing
* into.
* @since OMERO Beta 4.2.1.
*/
public List<Pixels> importImage(
final ImportContainer container, int index, int numDone, int total)
throws FormatException, IOException, Throwable {
HandlePrx handle;
for (FileExclusion exclusion : exclusions) {
Boolean veto = exclusion.suggestExclusion(store.getServiceFactory(), container);
if (Boolean.TRUE.equals(veto)) {
notifyObservers(
new ImportEvent.FILESET_EXCLUSION(
container.getFile().getAbsolutePath(), 0, container.getUsedFiles().length));
return Collections.emptyList();
}
}
final ImportProcessPrx proc = createImport(container);
final String[] srcFiles = container.getUsedFiles();
final List<String> checksums = new ArrayList<String>();
final byte[] buf = new byte[store.getDefaultBlockSize()];
final TimeEstimator estimator =
new ProportionalTimeEstimatorImpl(container.getUsedFilesTotalSize());
Map<Integer, String> failingChecksums = new HashMap<Integer, String>();
notifyObservers(
new ImportEvent.FILESET_UPLOAD_START(null, index, srcFiles.length, null, null, null));
for (int i = 0; i < srcFiles.length; i++) {
checksums.add(uploadFile(proc, srcFiles, i, checksumProviderFactory, estimator, buf));
}
try {
handle = proc.verifyUpload(checksums);
} catch (ChecksumValidationException cve) {
failingChecksums = cve.failingChecksums;
throw cve;
} finally {
try {
proc.close();
} catch (Exception e) {
log.warn("Exception while closing proc", e);
}
notifyObservers(
new ImportEvent.FILESET_UPLOAD_END(
null,
index,
srcFiles.length,
null,
null,
srcFiles,
checksums,
failingChecksums,
null));
}
// At this point the import is running, check handle for number of
// steps.
ImportCallback cb = null;
try {
cb = createCallback(proc, handle, container);
if (minutesToWait == 0) {
log.info("Disconnecting from import process...");
cb.close(false);
cb = null;
handle = null;
return Collections.emptyList(); // EARLY EXIT
}
if (minutesToWait < 0) {
while (true) {
if (cb.block(5000)) {
break;
}
}
} else {
cb.loop(minutesToWait * 30, 2000);
}
final ImportResponse rsp = cb.getImportResponse();
if (rsp == null) {
throw new Exception("Import failure");
}
return rsp.pixels;
} finally {
if (cb != null) {
cb.close(true); // Allow cb to close handle
} else if (handle != null) {
handle.close();
}
}
}