12176 attach fsfiles

components/blitz/resources/ome/services/blitz-servantDefinitions.xml

@@ -362,6 +362,7 @@
 
   <bean class="omero.cmd.RequestObjectFactoryRegistry" lazy-init="false">
       <constructor-arg ref="extendedMetadata"/>
+      <constructor-arg ref="aclVoter"/>
       <constructor-arg ref="roles"/>
       <constructor-arg ref="/OMERO/Pixels"/>
       <property name="iceCommunicator" ref="Ice.Communicator"/>

components/blitz/resources/omero/Repositories.ice

@@ -432,11 +432,14 @@ module omero {
         ["ami"] interface ManagedRepository extends Repository {
 
             /**
-             * Returns the directory which should be the import location for
-             * the set of paths passed in. Each set of paths consitutes a
-             * single import session. In order to prevent files from being
-             * overwritten or interfering with one another, a new directory
-             * may be created for the current session.
+             * Returns an [ImportProcess] which can be used to upload files.
+             * On [ImportProcess::verifyUpload], an [omero::cmd::Handle] will be
+             * returned which can be watched for knowing when the server-side import
+             * is complete.
+             *
+             * Once the upload is complete, the [ImportProcess] must be closed.
+             * Once [omero::cmd::Handle::getResponse] returns a non-null value, the
+             * handle instance can and must be closed.
              **/
             ImportProcess* importFileset(omero::model::Fileset fs, ImportSettings settings) throws ServerError;
 

components/blitz/resources/omero/cmd/FS.ice

@@ -72,6 +72,51 @@ module omero {
              **/
             omero::RTypeDict seriesMetadata;
         };
+
+        /**
+         * Queries and modifies the various binary artifacts
+         * which may be linked to an [omero::model::Image].
+         *
+         * This can be useful, e.g., after converting pre-OMERO-5
+         * archived original files into [omero::model::Fileset].
+         *
+         * The command works in several stages:
+         *
+         *   1. loads an [omero::model::Image] by id, failing if none present.
+         *   2. renames Pixels file to '*_bak'
+         *   3. deletes existing Pyramidfiles if present;
+         *
+         * This command can be run multiple times with different settings
+         * to iteratively test if the migration is working.
+         **/
+        class ManageImageBinaries extends Request {
+
+            long imageId;
+            bool togglePixels;
+            bool deletePyramid;
+
+        };
+
+        /**
+         * [Response] from a [ManageImageBinaries] [Request].
+         * If no action is requested, then the fields of this
+         * instance can be examined to see what would be done
+         * if requested.
+         */
+        class ManageImageBinariesResponse extends Response {
+
+            omero::RLong filesetId;
+            omero::api::LongList archivedFiles;
+            bool pixelsPresent;
+            bool pyramidPresent;
+            long archivedSize;
+            long pixelSize;
+            long pyramidSize;
+            long thumbnailSize;
+
+        };
+
+
     };
 };
 

components/blitz/src/ome/services/blitz/repo/ManagedImportProcessI.java

@@ -136,12 +136,6 @@ void setOffset(long offset) {
     /**
      * Create and register a servant for servicing the import process
      * within a managed repository.
-     *
-     * @param repo
-     * @param fs
-     * @param location
-     * @param settings
-     * @param __current
      */
     public ManagedImportProcessI(ManagedRepositoryI repo, Fileset fs,
             ImportLocation location, ImportSettings settings, Current __current)

components/blitz/src/ome/services/blitz/repo/ManagedRepositoryI.java

@@ -159,13 +159,33 @@ public Ice.Object tie() {
     // INTERFACE METHODS
     //
 
+    /**
+     * Return a template based directory path. The path will be created
+     * by calling {@link #makeDir(String, boolean, Ice.Current)}.
+     */
+    public ImportProcessPrx uploadFileset(Fileset fs, ImportSettings settings,
+            Ice.Current __current) throws omero.ServerError {
+
+        ImportLocation location = internalImport(fs, settings, __current);
+        return createUploadProcess(fs, location, settings, __current, true);
+
+    }
+
     /**
      * Return a template based directory path. The path will be created
      * by calling {@link #makeDir(String, boolean, Ice.Current)}.
      */
     public ImportProcessPrx importFileset(Fileset fs, ImportSettings settings,
             Ice.Current __current) throws omero.ServerError {
 
+        ImportLocation location = internalImport(fs, settings, __current);
+        return createImportProcess(fs, location, settings, __current);
+
+    }
+
+    private ImportLocation internalImport(Fileset fs, ImportSettings settings,
+            Ice.Current __current) throws omero.ServerError {
+
         if (fs == null || fs.sizeOfUsedFiles() < 1) {
             throw new omero.ApiUsageException(null, null, "No paths provided");
         }
@@ -198,10 +218,9 @@ public ImportProcessPrx importFileset(Fileset fs, ImportSettings settings,
 
         // If any two files clash in that chosen basePath directory, then
         // we want to suggest a similar alternative.
-        ImportLocation location =
-                suggestImportPaths(relPath, basePath, paths, readerClass, settings.checksumAlgorithm, __current);
+        return suggestImportPaths(relPath, basePath, paths, readerClass,
+                settings.checksumAlgorithm, __current);
 
-        return createImportProcess(fs, location, settings, __current);
     }
 
     public ImportProcessPrx importPaths(List<String> paths,
@@ -331,6 +350,19 @@ protected ImportProcessPrx createImportProcess(Fileset fs,
             job.linkOriginalFile((omero.model.OriginalFile) new IceMapper().map(of));
         }
 
+        return createUploadProcess(fs, location, settings, __current, false);
+    }
+
+    /**
+     * Creating the process will register itself in an appropriate
+     * container (i.e. a SessionI or similar) for the current
+     * user and therefore this instance no longer needs to worry
+     * about the maintenance of the object.
+     */
+    protected ImportProcessPrx createUploadProcess(Fileset fs,
+            ImportLocation location, ImportSettings settings,
+            Current __current, boolean uploadOnly) throws ServerError {
+
         // Create CheckedPath objects for use by saveFileset
         final int size = fs.sizeOfUsedFiles();
         final List<CheckedPath> checked = new ArrayList<CheckedPath>();
@@ -343,8 +375,8 @@ protected ImportProcessPrx createImportProcess(Fileset fs,
         // Since the fileset saved validly, we create a session for the user
         // and return the process.
 
-        final ManagedImportProcessI proc = new ManagedImportProcessI(this, managedFs,
-                location, settings, __current);
+        final ManagedImportProcessI proc = new ManagedImportProcessI(this,
+                managedFs, location, settings, __current);
         processes.addProcess(proc);
         return proc.getProxy();
     }
@@ -358,12 +390,16 @@ protected ImportProcessPrx createImportProcess(Fileset fs,
     protected Class<? extends FormatReader> getReaderClass(Fileset fs, Current __current) {
         for (final Job job : fs.linkedJobList()) {
             if (job instanceof UploadJob) {
-                final FilesetVersionInfo versionInfo = ((UploadJob) job).getVersionInfo(__current);
-                final String readerName = versionInfo.getBioformatsReader(__current).getValue();
-                final Class<?> potentialReaderClass;
+                Class<?> potentialReaderClass;
                 try {
+                    final FilesetVersionInfo versionInfo = ((UploadJob) job).getVersionInfo(__current);
+                    final String readerName = versionInfo.getBioformatsReader(__current).getValue();
                     potentialReaderClass = Class.forName(readerName);
-                } catch (ClassNotFoundException e) {
+                } catch (NullPointerException npe) {
+                    log.debug("No info provided for reader class");
+                    continue;
+                } catch (Exception e) {
+                    log.warn("Error getting reader class", e);
                     continue;
                 }
                 if (FormatReader.class.isAssignableFrom(potentialReaderClass)) {

components/blitz/src/omero/cmd/RequestObjectFactoryRegistry.java

@@ -16,6 +16,7 @@
 
 import ome.io.nio.AbstractFileSystemService;
 import ome.io.nio.PixelsService;
+import ome.security.ACLVoter;
 import ome.security.ChmodStrategy;
 import ome.services.chgrp.ChgrpStepFactory;
 import ome.services.chown.ChownStepFactory;
@@ -28,6 +29,7 @@
 import omero.cmd.basic.DoAllI;
 import omero.cmd.basic.ListRequestsI;
 import omero.cmd.basic.TimingI;
+import omero.cmd.fs.ManageImageBinariesI;
 import omero.cmd.fs.OriginalMetadataRequestI;
 import omero.cmd.graphs.ChgrpI;
 import omero.cmd.graphs.ChmodI;
@@ -47,16 +49,21 @@ public class RequestObjectFactoryRegistry extends
 
     private final ExtendedMetadata em;
 
+    private final ACLVoter voter;
+
     private final Roles roles;
 
     private final PixelsService pixelsService;
 
     private/* final */OmeroContext ctx;
 
-    public RequestObjectFactoryRegistry(ExtendedMetadata em, Roles roles,
+    public RequestObjectFactoryRegistry(ExtendedMetadata em,
+            ACLVoter voter,
+            Roles roles,
             PixelsService pixelsService) {
 
         this.em = em;
+        this.voter = voter;
         this.roles = roles;
         this.pixelsService = pixelsService;
 
@@ -149,6 +156,13 @@ public Ice.Object create(String name) {
                         return new OriginalMetadataRequestI(pixelsService);
                     }
                 });
+        factories.put(ManageImageBinariesI.ice_staticId(),
+                new ObjectFactory(ManageImageBinariesI.ice_staticId()) {
+                    @Override
+                    public Ice.Object create(String name) {
+                        return new ManageImageBinariesI(pixelsService, voter);
+                    }
+                });
         return factories;
     }