diff --git a/datastore_server/source/java/ch/systemsx/cisd/etlserver/registrator/AbstractOmniscientTopLevelDataSetRegistrator.java b/datastore_server/source/java/ch/systemsx/cisd/etlserver/registrator/AbstractOmniscientTopLevelDataSetRegistrator.java
index cf720ab6c2050e17edc67e1d89b47d5ed04c644e..14ee954b79ae8d1b1ad5334054bf6afb3d3d56ff 100644
--- a/datastore_server/source/java/ch/systemsx/cisd/etlserver/registrator/AbstractOmniscientTopLevelDataSetRegistrator.java
+++ b/datastore_server/source/java/ch/systemsx/cisd/etlserver/registrator/AbstractOmniscientTopLevelDataSetRegistrator.java
@@ -322,55 +322,54 @@ public abstract class AbstractOmniscientTopLevelDataSetRegistrator<T extends Dat
* Setup necessary for data set handling is done, then the handleDataSet method (a subclass
* responsibility) is invoked.
*/
- public final void handle(File incomingDataSetFileOrIsFinishedFile)
+ public final void handle(final File incomingDataSetFileOrIsFinishedFile)
{
if (stopped)
{
return;
}
- if (isRecoveryMarkerFile(incomingDataSetFileOrIsFinishedFile))
+ // get the original incoming dataset file
+ final File incomingDataSetFile =
+ getGlobalState().isUseIsFinishedMarkerFile() ? state.getMarkerFileUtility()
+ .getIncomingDataSetPathFromMarker(incomingDataSetFileOrIsFinishedFile)
+ : incomingDataSetFileOrIsFinishedFile;
+
+ if (isRecoveryMarkerFile(incomingDataSetFile))
{
- handleRecovery(incomingDataSetFileOrIsFinishedFile);
+ handleRecovery(incomingDataSetFile);
return;
- } else if (hasRecoveryMarkerFile(incomingDataSetFileOrIsFinishedFile))
+ } else if (hasRecoveryMarkerFile(incomingDataSetFile))
{
operationLog.info("Ignore file, as the recovery marker exists for it: "
- + incomingDataSetFileOrIsFinishedFile.getAbsolutePath());
+ + incomingDataSetFile.getAbsolutePath());
// will handle only the recovery file - don't do anything
return;
- } else if (false == incomingDataSetFileOrIsFinishedFile.exists())
+ } else if (false == incomingDataSetFile.exists())
{
- operationLog.info("The file doesn't exist: "
- + incomingDataSetFileOrIsFinishedFile.getAbsolutePath());
+ operationLog.info("The file doesn't exist: " + incomingDataSetFile.getAbsolutePath());
// it can mean that the recovery has already cleaned this file
return;
}
- final File isFinishedFile = incomingDataSetFileOrIsFinishedFile;
- final File incomingDataSetFile;
final IDelegatedActionWithResult<Boolean> markerFileCleanupAction;
// Figure out what the real incoming data is -- if we use a marker file, it will tell us the
// name
if (getGlobalState().isUseIsFinishedMarkerFile())
{
- incomingDataSetFile =
- state.getMarkerFileUtility().getIncomingDataSetPathFromMarker(isFinishedFile);
-
markerFileCleanupAction = new IDelegatedActionWithResult<Boolean>()
{
public Boolean execute(boolean didOperationSucceed)
{
boolean markerDeleteSucceeded =
state.getMarkerFileUtility().deleteAndLogIsFinishedMarkerFile(
- isFinishedFile);
+ incomingDataSetFileOrIsFinishedFile);
return markerDeleteSucceeded;
}
};
} else
{
- incomingDataSetFile = incomingDataSetFileOrIsFinishedFile;
markerFileCleanupAction = new DoNothingDelegatedAction();
}
@@ -492,8 +491,9 @@ public abstract class AbstractOmniscientTopLevelDataSetRegistrator<T extends Dat
state.getGlobalState().getStorageRecoveryManager()
.extractPrecommittedCheckpoint(recoveryMarkerFile);
- // TODO: cleanup also with the incoming marker file
-
+ // TODO: cleanup also with the incoming marker file, or are we guaranteed that the marker
+ // file is gone at this step.
+ // then we should ensure that the recovery will actually take place itself!
final File recoveryFile =
state.getGlobalState().getStorageRecoveryManager()
.getRecoveryFileFromMarker(recoveryMarkerFile);
@@ -596,7 +596,7 @@ public abstract class AbstractOmniscientTopLevelDataSetRegistrator<T extends Dat
.getGlobalState().getStagingDir());
recoveryState.getRollbackStack().setLockedState(false);
-
+
recoveryState.getRollbackStack().rollbackAll(rollbackStackDelegate);
UnstoreDataAction action =
state.getOnErrorActionDecision().computeUndoAction(
@@ -619,6 +619,11 @@ public abstract class AbstractOmniscientTopLevelDataSetRegistrator<T extends Dat
logger.registerSuccess();
registrationSuccessful = true;
}
+ } catch (org.jmock.api.ExpectationError r)
+ {
+ // this exception can by only thrown by tests.
+ // propagation of the exception is essential to test some functionalities
+ throw r;
} catch (Throwable error)
{
System.err.println("Caught an error! " + error);
diff --git a/datastore_server/sourceTest/java/ch/systemsx/cisd/etlserver/registrator/AbstractJythonDataSetHandlerTest.java b/datastore_server/sourceTest/java/ch/systemsx/cisd/etlserver/registrator/AbstractJythonDataSetHandlerTest.java
index 59ff7c3cb2f945cf9f4d5c58f104970f0602759a..1d5da8f7cbc76ff8532e7297b71f95ae56a03adb 100644
--- a/datastore_server/sourceTest/java/ch/systemsx/cisd/etlserver/registrator/AbstractJythonDataSetHandlerTest.java
+++ b/datastore_server/sourceTest/java/ch/systemsx/cisd/etlserver/registrator/AbstractJythonDataSetHandlerTest.java
@@ -48,6 +48,7 @@ import ch.systemsx.cisd.etlserver.TopLevelDataSetRegistratorGlobalState;
import ch.systemsx.cisd.etlserver.validation.IDataSetValidator;
import ch.systemsx.cisd.openbis.dss.generic.shared.IEncapsulatedOpenBISService;
import ch.systemsx.cisd.openbis.dss.generic.shared.api.internal.v1.IDataSourceQueryService;
+import ch.systemsx.cisd.openbis.generic.shared.basic.dto.DataSetType;
import ch.systemsx.cisd.openbis.generic.shared.basic.dto.DatabaseInstance;
import ch.systemsx.cisd.openbis.generic.shared.dto.StorageFormat;
@@ -96,6 +97,21 @@ public abstract class AbstractJythonDataSetHandlerTest extends AbstractFileSyste
protected File subDataSet2;
+ protected static final String DATA_SET_CODE = "data-set-code";
+
+ protected static final String DATA_SET_CODE_1 = "data-set-code-1";
+
+ protected static final String CONTAINER_DATA_SET_CODE = "container-data-set-code";
+
+ protected static final DataSetType DATA_SET_TYPE = new DataSetType("O1");
+
+ protected static final String EXPERIMENT_PERM_ID = "experiment-perm-id";
+
+ protected static final String EXPERIMENT_IDENTIFIER = "/SPACE/PROJECT/EXP";
+
+ protected static final String SAMPLE_PERM_ID = "sample-perm-id";
+
+
@BeforeTest
public void init()
{
diff --git a/datastore_server/sourceTest/java/ch/systemsx/cisd/etlserver/registrator/JythonDropboxRecoveryTest.java b/datastore_server/sourceTest/java/ch/systemsx/cisd/etlserver/registrator/JythonDropboxRecoveryTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..76613f6745465b35bcafc2588af9119c7c39049b
--- /dev/null
+++ b/datastore_server/sourceTest/java/ch/systemsx/cisd/etlserver/registrator/JythonDropboxRecoveryTest.java
@@ -0,0 +1,294 @@
+/*
+ * Copyright 2012 ETH Zuerich, CISD
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package ch.systemsx.cisd.etlserver.registrator;
+
+import static ch.systemsx.cisd.common.Constants.IS_FINISHED_PREFIX;
+
+import java.io.File;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Properties;
+
+import org.jmock.Expectations;
+import org.testng.annotations.DataProvider;
+import org.testng.annotations.Test;
+
+import ch.systemsx.cisd.common.filesystem.FileUtilities;
+import ch.systemsx.cisd.common.test.RecordingMatcher;
+import ch.systemsx.cisd.openbis.generic.shared.basic.dto.Experiment;
+import ch.systemsx.cisd.openbis.generic.shared.basic.dto.ExternalData;
+import ch.systemsx.cisd.openbis.generic.shared.basic.dto.builders.ExperimentBuilder;
+import ch.systemsx.cisd.openbis.generic.shared.dto.AtomicEntityOperationDetails;
+import ch.systemsx.cisd.openbis.generic.shared.dto.identifier.ExperimentIdentifierFactory;
+
+/**
+ * @author jakubs
+ */
+public class JythonDropboxRecoveryTest extends AbstractJythonDataSetHandlerTest
+{
+ private static final String SCRIPTS_FOLDER =
+ "sourceTest/java/ch/systemsx/cisd/etlserver/registrator/";
+
+ @Override
+ protected String getRegistrationScriptsFolderPath()
+ {
+ return SCRIPTS_FOLDER;
+ }
+
+ @DataProvider(name = "recoveryTestCaseProvider")
+ public Object[][] recoveryTestCases()
+ {
+ LinkedList<RecoveryTestCase> testCases = new LinkedList<RecoveryTestCase>();
+ RecoveryTestCase testCase;
+
+ testCase = new RecoveryTestCase("Basic recovery testcase");
+ testCases.add(testCase);
+
+ // result value
+ Object[][] resultsList = new Object[testCases.size()][];
+ int index = 0;
+ for (RecoveryTestCase t : testCases)
+ {
+ resultsList[index++] = new Object[]
+ { t };
+ }
+
+ return resultsList;
+ }
+
+ private static class RecoveryTestCase
+ {
+
+ /**
+ * short description of the test. Will be presented in the test results view
+ */
+ protected String title;
+
+ /**
+ * The dropbox script file that should be used for this test case
+ */
+ protected String dropboxScriptPath = "simple-testcase.py";
+
+ /**
+ * Specifies what properties should be overriden for this test case.
+ */
+ protected HashMap<String, String> overrideProperties;
+
+ /**
+ * If true, than autorecovery should take place. If not, then transaction should be rolled
+ * back, and recovery artifacts removed.
+ */
+ protected boolean canRecoverFromError = true;
+
+ /**
+ * If true than this registration has been succesfull. Which means that the recovery should
+ * continue registration rather rollback.
+ */
+ protected boolean registrationSuccesfull = true;
+
+ /**
+ * True if the registration should throw exception to the top level. With this setting the
+ * handler is said to throw all exception to the top level, so that we can catch them. To
+ * check how the system reacts to error's itself (like rollback mechanism) this should be
+ * set to false.
+ */
+ protected boolean shouldThrowExceptionDuringRegistration = true;
+
+ private RecoveryTestCase(String title)
+ {
+ this.title = title;
+ this.overrideProperties = new HashMap<String, String>();
+ this.overrideProperties.put("TEST_V2_API", "");
+ }
+
+ @Override
+ public String toString()
+ {
+ return title;
+ }
+ }
+
+ @Test(dataProvider = "recoveryTestCaseProvider")
+ public void testRecovery(final RecoveryTestCase testCase)
+ {
+ setUpHomeDataBaseExpectations();
+
+ createData();
+
+ Properties properties =
+ createThreadPropertiesRelativeToScriptsFolder(testCase.dropboxScriptPath,
+ testCase.overrideProperties);
+
+ createHandler(properties, true, false);
+
+ final RecordingMatcher<ch.systemsx.cisd.openbis.generic.shared.dto.AtomicEntityOperationDetails> atomicatOperationDetails =
+ new RecordingMatcher<ch.systemsx.cisd.openbis.generic.shared.dto.AtomicEntityOperationDetails>();
+
+ context.checking(new RecoveryTestExpectations(testCase, atomicatOperationDetails));
+
+ // create expectations:
+ // the expectations are up to the point when the registration in openbis fails
+
+ // run the actual code
+ handler.handle(markerFile);
+ if (testCase.canRecoverFromError)
+ {
+ File dir =
+ new File(
+ "/Users/jakubs/Documents/git/datastore_server/targets/unit-test-wd/ch.systemsx.cisd.etlserver.registrator.JythonDropboxRecoveryTest/");
+ for (Object f : dir.list())
+ {
+ System.out.println("XX:" + f);
+ }
+ File recoveryMarkerFile = getCreatedRecoveryMarkerFile();
+
+ handler.handle(recoveryMarkerFile);
+ } else
+ {
+ // rolllback requirementes
+ }
+
+ // now! we know that the error has happened
+
+ // then we assert there exists a recovery file
+ // assert there is a recovery marker file
+
+ // we continue with the recovery
+
+ }
+
+ private File getCreatedRecoveryMarkerFile()
+ {
+ File originalIncoming =
+ FileUtilities.removePrefixFromFileName(markerFile, IS_FINISHED_PREFIX);
+ File recoveryMarkerFile =
+ new File(originalIncoming.getAbsolutePath()
+ + IDataSetStorageRecoveryManager.PROCESSING_MARKER);
+ assertTrue("The recovery marker file does not exist! " + recoveryMarkerFile,
+ recoveryMarkerFile.exists());
+ return recoveryMarkerFile;
+ }
+
+ class RecoveryTestExpectations extends Expectations
+ {
+ final RecoveryTestCase testCase;
+
+ final Experiment experiment;
+
+ final RecordingMatcher<AtomicEntityOperationDetails> atomicatOperationDetails;
+
+ public RecoveryTestExpectations(final RecoveryTestCase testCase,
+ final RecordingMatcher<AtomicEntityOperationDetails> atomicatOperationDetails)
+ {
+ this.testCase = testCase;
+ ExperimentBuilder builder = new ExperimentBuilder().identifier(EXPERIMENT_IDENTIFIER);
+ this.experiment = builder.getExperiment();
+
+ this.atomicatOperationDetails = atomicatOperationDetails;
+
+ prepareExpecatations();
+ }
+
+ private void prepareExpecatations()
+ {
+ initialExpectations();
+
+ registerDataSets();
+
+ // now registration has failed with the exception. we continue depending on where
+
+ if (testCase.canRecoverFromError)
+ {
+ checkRegistrationSucceeded();
+
+ if (testCase.registrationSuccesfull)
+ {
+ setStorageConfirmed();
+ }
+ } else
+ {
+ // rollback
+ }
+ }
+
+ protected void initialExpectations()
+ {
+
+ // create dataset
+ one(openBisService).createDataSetCode();
+ will(returnValue(DATA_SET_CODE));
+
+ // get experiment
+ atLeast(1).of(openBisService).tryToGetExperiment(
+ new ExperimentIdentifierFactory(experiment.getIdentifier()).createIdentifier());
+ will(returnValue(experiment));
+
+ // validate dataset
+ one(dataSetValidator).assertValidDataSet(DATA_SET_TYPE,
+ new File(new File(stagingDirectory, DATA_SET_CODE), "sub_data_set_1"));
+ }
+
+ protected void registerDataSets()
+ {
+ one(openBisService).performEntityOperations(with(atomicatOperationDetails));
+
+ Exception e = new IllegalArgumentException("Failure in atomicOperationDetails");
+ will(throwException(e));
+
+ }
+
+ protected void checkRegistrationSucceeded()
+ {
+ one(openBisService).listDataSetsByCode(Arrays.asList(DATA_SET_CODE));
+ if (testCase.registrationSuccesfull)
+ {
+ // with the current implemntation returning the non-empty list should be enough
+ List<ExternalData> externalDatas = (List) Arrays.asList(new Object());
+ will(returnValue(externalDatas));
+ } else
+ {
+ will(returnValue(new LinkedList<ExternalData>()));
+ }
+ }
+
+ protected void setStorageConfirmed()
+ {
+ one(openBisService).setStorageConfirmed(DATA_SET_CODE);
+ }
+
+ }
+
+ /**
+ * creates a very simple dataset to import
+ */
+ private void createData()
+ {
+ incomingDataSetFile = createDirectory(workingDirectory, "data_set");
+
+ assertTrue(incomingDataSetFile.isDirectory());
+
+ subDataSet1 = createDirectory(incomingDataSetFile, "sub_data_set_1");
+
+ FileUtilities.writeToFile(new File(subDataSet1, "read1.me"), "hello world1");
+
+ markerFile = new File(workingDirectory, IS_FINISHED_PREFIX + "data_set");
+ FileUtilities.writeToFile(markerFile, "");
+ }
+
+}
diff --git a/datastore_server/sourceTest/java/ch/systemsx/cisd/etlserver/registrator/JythonTopLevelDataSetRegistratorRollbackTest.java b/datastore_server/sourceTest/java/ch/systemsx/cisd/etlserver/registrator/JythonTopLevelDataSetRegistratorRollbackTest.java
index 867b511cc395c293782700cbe4425a07ee76e80b..5816e2b423b79cd89b630342875104a9354b4059 100644
--- a/datastore_server/sourceTest/java/ch/systemsx/cisd/etlserver/registrator/JythonTopLevelDataSetRegistratorRollbackTest.java
+++ b/datastore_server/sourceTest/java/ch/systemsx/cisd/etlserver/registrator/JythonTopLevelDataSetRegistratorRollbackTest.java
@@ -48,12 +48,6 @@ public class JythonTopLevelDataSetRegistratorRollbackTest extends AbstractJython
private static final String SCRIPTS_FOLDER =
"sourceTest/java/ch/systemsx/cisd/etlserver/registrator/";
- private static final String DATA_SET_CODE = "data-set-code";
-
- private static final DataSetType DATA_SET_TYPE = new DataSetType("O1");
-
- private static final String EXPERIMENT_IDENTIFIER = "/SPACE/PROJECT/EXP";
-
@BeforeMethod
@Override
public void setUp() throws IOException
diff --git a/datastore_server/sourceTest/java/ch/systemsx/cisd/etlserver/registrator/JythonTopLevelDataSetRegistratorTest.java b/datastore_server/sourceTest/java/ch/systemsx/cisd/etlserver/registrator/JythonTopLevelDataSetRegistratorTest.java
index 40405dcd8cd550bcfaee311e89f13f1f6834d75a..754d620584cf786e5d3d6a048d8807b0af03f905 100644
--- a/datastore_server/sourceTest/java/ch/systemsx/cisd/etlserver/registrator/JythonTopLevelDataSetRegistratorTest.java
+++ b/datastore_server/sourceTest/java/ch/systemsx/cisd/etlserver/registrator/JythonTopLevelDataSetRegistratorTest.java
@@ -31,7 +31,6 @@ import java.util.Map;
import java.util.Properties;
import org.jmock.Expectations;
-import org.jmock.api.ExpectationError;
import org.jmock.api.Invocation;
import org.jmock.lib.action.CustomAction;
import org.python.core.PyException;
@@ -56,7 +55,6 @@ import ch.systemsx.cisd.openbis.generic.shared.api.v1.dto.SearchCriteria;
import ch.systemsx.cisd.openbis.generic.shared.api.v1.dto.SearchCriteria.MatchClause;
import ch.systemsx.cisd.openbis.generic.shared.api.v1.dto.SearchCriteria.MatchClauseAttribute;
import ch.systemsx.cisd.openbis.generic.shared.basic.dto.ContainerDataSet;
-import ch.systemsx.cisd.openbis.generic.shared.basic.dto.DataSetType;
import ch.systemsx.cisd.openbis.generic.shared.basic.dto.EntityProperty;
import ch.systemsx.cisd.openbis.generic.shared.basic.dto.Experiment;
import ch.systemsx.cisd.openbis.generic.shared.basic.dto.NewExperiment;
@@ -82,20 +80,6 @@ public class JythonTopLevelDataSetRegistratorTest extends AbstractJythonDataSetH
private static final String SCRIPTS_FOLDER =
"sourceTest/java/ch/systemsx/cisd/etlserver/registrator/";
- private static final String DATA_SET_CODE = "data-set-code";
-
- private static final String DATA_SET_CODE_1 = "data-set-code-1";
-
- private static final String CONTAINER_DATA_SET_CODE = "container-data-set-code";
-
- private static final DataSetType DATA_SET_TYPE = new DataSetType("O1");
-
- private static final String EXPERIMENT_PERM_ID = "experiment-perm-id";
-
- private static final String EXPERIMENT_IDENTIFIER = "/SPACE/PROJECT/EXP";
-
- private static final String SAMPLE_PERM_ID = "sample-perm-id";
-
@BeforeMethod
@Override
public void setUp() throws IOException
@@ -212,7 +196,6 @@ public class JythonTopLevelDataSetRegistratorTest extends AbstractJythonDataSetH
testCase.failurePoint = TestCaseParameters.FailurePoint.DURING_OPENBIS_REGISTRATION;
testCases.addAll(multipleVersionsOfTestCase(testCase));
- // TODO: In this case should it be "invalid dataset error" or what?
testCase = new TestCaseParameters("The validation error with DELETE on error.");
for (String error : allErrors)
{
@@ -336,6 +319,8 @@ public class JythonTopLevelDataSetRegistratorTest extends AbstractJythonDataSetH
return resultsList;
}
+ //INFO: testCase parameters
+
/**
* Parameters for the single run of the testSimpleTransaction
*
@@ -443,6 +428,7 @@ public class JythonTopLevelDataSetRegistratorTest extends AbstractJythonDataSetH
}
}
+ //INFO: test simple transaction
@Test(dataProvider = "simpleTransactionTestCaseProvider")
public void testSimpleTransaction(final TestCaseParameters testCase)
{
@@ -463,12 +449,10 @@ public class JythonTopLevelDataSetRegistratorTest extends AbstractJythonDataSetH
createDataWithOneSubDataSet();
}
- ExperimentBuilder builder = new ExperimentBuilder().identifier(EXPERIMENT_IDENTIFIER);
- final Experiment experiment = builder.getExperiment();
final RecordingMatcher<ch.systemsx.cisd.openbis.generic.shared.dto.AtomicEntityOperationDetails> atomicatOperationDetails =
new RecordingMatcher<ch.systemsx.cisd.openbis.generic.shared.dto.AtomicEntityOperationDetails>();
- context.checking(getSimpleTransactionExpectations(testCase, experiment, atomicatOperationDetails));
+ context.checking(getSimpleTransactionExpectations(testCase, atomicatOperationDetails));
if (testCase.shouldThrowExceptionDuringRegistration)
{
@@ -533,9 +517,9 @@ public class JythonTopLevelDataSetRegistratorTest extends AbstractJythonDataSetH
public Expectations getSimpleTransactionExpectations(
final TestCaseParameters testCase,
- final Experiment experiment,
- final RecordingMatcher<ch.systemsx.cisd.openbis.generic.shared.dto.AtomicEntityOperationDetails> atomicatOperationDetails)
+ final RecordingMatcher<AtomicEntityOperationDetails> atomicatOperationDetails)
{
+ final Experiment experiment = new ExperimentBuilder().identifier(EXPERIMENT_IDENTIFIER).getExperiment();
return new Expectations()
{
{