SSDM-8929: ArchivingAggreationService output: Error included and jsonized result

datastore_server/source/java/ch/systemsx/cisd/openbis/dss/generic/server/plugins/standard/ArchivingAggregationService.java

@@ -30,10 +30,14 @@ import java.util.TreeMap;
 import java.util.TreeSet;
 import java.util.stream.Collectors;
 
+import com.fasterxml.jackson.core.JsonProcessingException;
+
 import ch.ethz.sis.openbis.generic.asapi.v3.IApplicationServerApi;
 import ch.ethz.sis.openbis.generic.asapi.v3.dto.dataset.DataSet;
 import ch.ethz.sis.openbis.generic.asapi.v3.dto.dataset.fetchoptions.DataSetFetchOptions;
 import ch.ethz.sis.openbis.generic.asapi.v3.dto.dataset.id.DataSetPermId;
+import ch.ethz.sis.openbis.generic.server.sharedapi.v3.json.GenericObjectMapper;
+import ch.systemsx.cisd.base.exceptions.CheckedExceptionTunnel;
 import ch.systemsx.cisd.common.exceptions.UserFailureException;
 import ch.systemsx.cisd.openbis.dss.generic.shared.DataSetProcessingContext;
 import ch.systemsx.cisd.openbis.dss.generic.shared.IArchiverPlugin;
@@ -49,13 +53,10 @@ import ch.systemsx.cisd.openbis.generic.shared.util.SimpleTableModelBuilder;
 public class ArchivingAggregationService extends AggregationService
 {
     static final String METHOD_KEY = "method";
+
     static final String ARGS_KEY = "args";
-    static final String GET_ARCHIVING_INFO_METHOD = "getArchivingInfo";
-    private static final String DATA_SET_COLUMN = "DataSet";
-    private static final String SIZE_COLUMN = "Size";
-    private static final String CONTAINER_SIZE_COLUMN = "ContainerSize";
-    private static final String CONTAINER_COLUMN = "Container";
 
+    static final String GET_ARCHIVING_INFO_METHOD = "getArchivingInfo";
 
     private static final long serialVersionUID = 1L;
 
@@ -74,17 +75,24 @@ public class ArchivingAggregationService extends AggregationService
         this.v3api = v3api;
         this.archiver = archiver;
     }
-    
+
     @Override
     public TableModel createAggregationReport(Map<String, Object> parameters, DataSetProcessingContext context)
     {
-        Object method = parameters.get(METHOD_KEY);
-        List<String> arguments = getArguments(parameters);
-        if (GET_ARCHIVING_INFO_METHOD.equals(method))
+        try
+        {
+            Object method = parameters.get(METHOD_KEY);
+            List<String> arguments = getArguments(parameters);
+            if (GET_ARCHIVING_INFO_METHOD.equals(method))
+            {
+                return getArchivingInfo(context.trySessionToken(), arguments);
+            }
+            throw new UserFailureException("Unknown method '" + method + "'.");
+        } catch (Throwable e)
         {
-            return getArchivingInfo(context.trySessionToken(), arguments);
+            logInvocationError(parameters, e);
+            return errorTableModel(parameters, e);
         }
-        throw new UserFailureException("Unknown method '" + method + "'.");
     }
 
     private TableModel getArchivingInfo(String sessionToken, List<String> dataSetCodes)
@@ -95,24 +103,34 @@ public class ArchivingAggregationService extends AggregationService
         Map<String, Long> containerSizes = getContainerSizes(containersByDataSetCode, dataSetSizes);
         long totalSize = getTotalSize(allDataSets, dataSetSizes);
 
-        SimpleTableModelBuilder builder = new SimpleTableModelBuilder(true);
-        builder.addHeader(DATA_SET_COLUMN);
-        builder.addHeader(SIZE_COLUMN);
-        builder.addHeader(CONTAINER_COLUMN);
-        builder.addHeader(CONTAINER_SIZE_COLUMN);
-        Set<Entry<String, Set<String>>> entrySet = containersByDataSetCode.entrySet();
-        for (Entry<String, Set<String>> entry : entrySet)
+        Map<String, Object> infos = new TreeMap<>();
+        infos.put("total size", totalSize);
+        for (Entry<String, Set<String>> entry : containersByDataSetCode.entrySet())
         {
-            IRowBuilder row = builder.addRow();
+            Map<String, Object> info = new TreeMap<>();
             String dataSetCode = entry.getKey();
-            row.setCell(DATA_SET_COLUMN, dataSetCode);
-            row.setCell(SIZE_COLUMN, dataSetSizes.get(dataSetCode));
-            row.setCell(CONTAINER_COLUMN, String.join(",", entry.getValue()));
-            row.setCell(CONTAINER_SIZE_COLUMN, containerSizes.get(dataSetCode));
+            info.put("size", dataSetSizes.get(dataSetCode));
+            info.put("container", entry.getValue());
+            info.put("container size", containerSizes.get(dataSetCode));
+            infos.put(dataSetCode, info);
         }
-        IRowBuilder row = builder.addRow();
-        row.setCell(SIZE_COLUMN, totalSize);
 
+        SimpleTableModelBuilder builder = new SimpleTableModelBuilder(true);
+        builder.addHeader("STATUS");
+        builder.addHeader("MESSAGE");
+        builder.addHeader("RESULT");
+        IRowBuilder row = builder.addRow();
+        row.setCell("STATUS","OK");
+        row.setCell("MESSAGE", "Operation Successful");
+        GenericObjectMapper objectMapper = new GenericObjectMapper();
+        try
+        {
+            String jsonValue = objectMapper.writeValueAsString(infos);
+            row.setCell("RESULT", jsonValue);
+        } catch (JsonProcessingException e)
+        {
+            throw CheckedExceptionTunnel.wrapIfNecessary(e);
+        }
         return builder.getTableModel();
     }
 

datastore_server/sourceTest/java/ch/systemsx/cisd/openbis/dss/generic/server/plugins/standard/ArchivingAggregationServiceTest.java

@@ -42,6 +42,7 @@ import ch.ethz.sis.openbis.generic.asapi.v3.dto.dataset.fetchoptions.DataSetFetc
 import ch.ethz.sis.openbis.generic.asapi.v3.dto.dataset.id.DataSetPermId;
 import ch.ethz.sis.openbis.generic.asapi.v3.dto.dataset.id.IDataSetId;
 import ch.systemsx.cisd.base.tests.AbstractFileSystemTestCase;
+import ch.systemsx.cisd.common.exceptions.UserFailureException;
 import ch.systemsx.cisd.common.mail.IMailClient;
 import ch.systemsx.cisd.common.test.RecordingMatcher;
 import ch.systemsx.cisd.openbis.dss.generic.shared.DataSetProcessingContext;
@@ -101,10 +102,11 @@ public class ArchivingAggregationServiceTest extends AbstractFileSystemTestCase
         List<TableModelRow> rows = service.createAggregationReport(parameters, processingContext).getRows();
 
         // Then
-        assertEquals("[[ds1, 10000, ds1, 10000]]\n"
-                + "[[ds2, 10010, ds2, 10010]]\n"
-                + "[[ds3, 10020, ds3, 10020]]\n"
-                + "[[, 30030, , ]]\n", renderRows(rows));
+        assertEquals("[[OK, Operation Successful, "
+                + "{\"ds1\":{\"container\":[\"ds1\"],\"container size\":10000,\"size\":10000},"
+                + "\"ds2\":{\"container\":[\"ds2\"],\"container size\":10010,\"size\":10010},"
+                + "\"ds3\":{\"container\":[\"ds3\"],\"container size\":10020,\"size\":10020},"
+                + "\"total size\":30030}]]\n", renderRows(rows));
         assertEquals("[DS1, DS2, DS3]", actualDataSetsMatcher.recordedObject().toString());
         context.assertIsSatisfied();
     }
@@ -125,14 +127,32 @@ public class ArchivingAggregationServiceTest extends AbstractFileSystemTestCase
         List<TableModelRow> rows = service.createAggregationReport(parameters, processingContext).getRows();
 
         // Then
-        assertEquals("[[ds1, 10000, ds1,ds10,ds9, 30060]]\n"
-                + "[[ds2, 10020, ds2,ds3,ds4, 30090]]\n"
-                + "[[ds3, 10040, ds2,ds3,ds4, 30090]]\n"
-                + "[[, 60150, , ]]\n", renderRows(rows));
+        assertEquals("[[OK, Operation Successful, "
+                + "{\"ds1\":{\"container\":[\"ds1\",\"ds10\",\"ds9\"],\"container size\":30060,\"size\":10000},"
+                + "\"ds2\":{\"container\":[\"ds2\",\"ds3\",\"ds4\"],\"container size\":30090,\"size\":10020},"
+                + "\"ds3\":{\"container\":[\"ds2\",\"ds3\",\"ds4\"],\"container size\":30090,\"size\":10040},"
+                + "\"total size\":60150}]]\n", renderRows(rows));
         assertEquals("[DS1, DS10, DS2, DS3, DS4, DS9]", actualDataSetsMatcher.recordedObject().toString());
         context.assertIsSatisfied();
     }
 
+    @Test
+    public void testTooLargeToUnarchive()
+    {
+        // Given
+        prepareGetContainer("ds1", new UserFailureException("Too large"));
+        Map<String, Object> parameters = new HashMap<>();
+        parameters.put(METHOD_KEY, GET_ARCHIVING_INFO_METHOD);
+        parameters.put(ArchivingAggregationService.ARGS_KEY, String.join(", ", "ds1"));
+
+        // When
+        List<TableModelRow> rows = service.createAggregationReport(parameters, processingContext).getRows();
+
+        // Then
+        assertEquals("[[{args=ds1, method=getArchivingInfo}, Too large]]\n", renderRows(rows));
+        context.assertIsSatisfied();
+    }
+
     private RecordingMatcher<List<DataSetPermId>> prepareGetDataSets(String... dataSetCodes)
     {
         DataSetFetchOptions fetchOptions = new DataSetFetchOptions();
@@ -196,6 +216,17 @@ public class ArchivingAggregationServiceTest extends AbstractFileSystemTestCase
             });
     }
 
+    private void prepareGetContainer(String dataSetCode, UserFailureException exception)
+    {
+        context.checking(new Expectations()
+            {
+                {
+                    allowing(archiver).getDataSetCodesForUnarchiving(Arrays.asList(dataSetCode));
+                    will(throwException(exception));
+                }
+            });
+    }
+
     private String renderRows(List<TableModelRow> rows)
     {
         StringBuilder builder = new StringBuilder();