diff --git a/ch.eitchnet.utils b/ch.eitchnet.utils index 97936b03f..d87517e4c 160000 --- a/ch.eitchnet.utils +++ b/ch.eitchnet.utils @@ -1 +1 @@ -Subproject commit 97936b03fe86ce421bbfe61efbd51a49da1f0868 +Subproject commit d87517e4c2a3e9507b2661cc1737031761d99b61 diff --git a/li.strolch.agent/src/main/java/li/strolch/migrations/CodeMigration.java b/li.strolch.agent/src/main/java/li/strolch/migrations/CodeMigration.java new file mode 100644 index 000000000..b7457efcf --- /dev/null +++ b/li.strolch.agent/src/main/java/li/strolch/migrations/CodeMigration.java @@ -0,0 +1,19 @@ +package li.strolch.migrations; + +import java.io.File; + +import li.strolch.agent.api.ComponentContainer; +import ch.eitchnet.privilege.model.Certificate; +import ch.eitchnet.utils.Version; + +public class CodeMigration extends Migration { + + public CodeMigration(String realm, Version version, File dataFile) { + super(realm, version, dataFile); + } + + @Override + public void migrate(ComponentContainer container, Certificate certificate) { + logger.info("[" + this.realm + "] Running migration " + this.version); + } +} diff --git a/li.strolch.agent/src/main/java/li/strolch/migrations/CurrentMigrationVersionQuery.java b/li.strolch.agent/src/main/java/li/strolch/migrations/CurrentMigrationVersionQuery.java new file mode 100644 index 000000000..d0335d2d7 --- /dev/null +++ b/li.strolch.agent/src/main/java/li/strolch/migrations/CurrentMigrationVersionQuery.java @@ -0,0 +1,68 @@ +package li.strolch.migrations; + +import java.util.HashMap; +import java.util.Map; + +import li.strolch.agent.api.ComponentContainer; +import li.strolch.agent.api.StrolchRealm; +import li.strolch.model.Resource; +import li.strolch.model.parameter.StringParameter; +import li.strolch.persistence.api.StrolchTransaction; +import li.strolch.runtime.configuration.StrolchConfigurationException; +import ch.eitchnet.privilege.model.Certificate; +import ch.eitchnet.utils.Version; + +public class CurrentMigrationVersionQuery { + + public static final String MIGRATIONS_TYPE = "Migrations"; + public static final String MIGRATIONS_ID = "migrations"; + public static final String BAG_PARAMETERS = "parameters"; + public static final String PARAM_CURRENT_VERSION = "currentVersion"; + + private ComponentContainer container; + private Map currentVersions; + + /** + * @param container + */ + public CurrentMigrationVersionQuery(ComponentContainer container) { + this.container = container; + } + + public void doQuery(Certificate cert) { + + this.currentVersions = new HashMap<>(); + + for (String realmName : this.container.getRealmNames()) { + StrolchRealm realm = this.container.getRealm(realmName); + try (StrolchTransaction tx = realm.openTx(cert, getClass())) { + + Resource migrationsRes = tx.getResourceBy(MIGRATIONS_TYPE, MIGRATIONS_ID); + if (migrationsRes == null) { + this.currentVersions.put(realmName, Version.emptyVersion); + continue; + } + + StringParameter currentVersionP = migrationsRes.getParameter(BAG_PARAMETERS, PARAM_CURRENT_VERSION); + if (currentVersionP == null) { + this.currentVersions.put(realmName, Version.emptyVersion); + continue; + } + + String versionS = currentVersionP.getValue(); + if (!Version.isParseable(versionS)) { + throw new StrolchConfigurationException("Version value " + versionS + " is not valid for " + + currentVersionP.getLocator()); + } + + Version version = Version.valueOf(versionS); + this.currentVersions.put(realmName, version); + } + } + } + + public Map getCurrentVersions() { + return this.currentVersions; + } + +} diff --git a/li.strolch.agent/src/main/java/li/strolch/migrations/DataMigration.java b/li.strolch.agent/src/main/java/li/strolch/migrations/DataMigration.java new file mode 100644 index 000000000..1e12a7e9b --- /dev/null +++ b/li.strolch.agent/src/main/java/li/strolch/migrations/DataMigration.java @@ -0,0 +1,20 @@ +package li.strolch.migrations; + +import java.io.File; + +import li.strolch.agent.api.ComponentContainer; +import ch.eitchnet.privilege.model.Certificate; +import ch.eitchnet.utils.Version; + +public class DataMigration extends Migration { + + public DataMigration(String realm, Version version, File dataFile) { + super(realm, version, dataFile); + } + + @Override + public void migrate(ComponentContainer container, Certificate certificate) { + + logger.info("[" + this.realm + "] Running migration " + this.version); + } +} diff --git a/li.strolch.agent/src/main/java/li/strolch/migrations/Migration.java b/li.strolch.agent/src/main/java/li/strolch/migrations/Migration.java new file mode 100644 index 000000000..28feeab49 --- /dev/null +++ b/li.strolch.agent/src/main/java/li/strolch/migrations/Migration.java @@ -0,0 +1,40 @@ +package li.strolch.migrations; + +import java.io.File; + +import li.strolch.agent.api.ComponentContainer; + +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import ch.eitchnet.privilege.model.Certificate; +import ch.eitchnet.utils.Version; + +public abstract class Migration { + + protected static final Logger logger = LoggerFactory.getLogger(CodeMigration.class); + + protected final String realm; + protected final Version version; + protected final File dataFile; + + public Migration(String realm, Version version, File dataFile) { + this.realm = realm; + this.version = version; + this.dataFile = dataFile; + } + + public String getRealm() { + return realm; + } + + public Version getVersion() { + return version; + } + + public File getDataFile() { + return dataFile; + } + + public abstract void migrate(ComponentContainer container, Certificate certificate); +} diff --git a/li.strolch.agent/src/main/java/li/strolch/migrations/Migrations.java b/li.strolch.agent/src/main/java/li/strolch/migrations/Migrations.java new file mode 100644 index 000000000..aa752cd1e --- /dev/null +++ b/li.strolch.agent/src/main/java/li/strolch/migrations/Migrations.java @@ -0,0 +1,207 @@ +package li.strolch.migrations; + +import java.io.File; +import java.io.FileFilter; +import java.util.HashMap; +import java.util.Map; +import java.util.Map.Entry; +import java.util.SortedSet; +import java.util.TreeSet; + +import li.strolch.agent.api.ComponentContainer; + +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import ch.eitchnet.privilege.model.Certificate; +import ch.eitchnet.utils.Version; +import ch.eitchnet.utils.collections.MapOfLists; +import ch.eitchnet.utils.dbc.DBC; + +public class Migrations { + + private static final Logger logger = LoggerFactory.getLogger(Migrations.class); + + private ComponentContainer container; + private Map currentVersions; + + private SortedSet dataMigrations; + private SortedSet codeMigrations; + + private Map migrationsRan; + + public Migrations(ComponentContainer container, Map currentVersions) { + this.container = container; + this.currentVersions = currentVersions; + } + + public Map getMigrationsRan() { + return this.migrationsRan; + } + + public void parseMigrations(File migrationsPath) { + DBC.PRE.assertTrue("If migrations path is not a directory!", migrationsPath.isDirectory()); + + // data migrations + this.dataMigrations = loadDataMigrations(this.currentVersions, migrationsPath); + + // code migrations + this.codeMigrations = loadCodeMigrations(this.currentVersions, migrationsPath); + + // log found migrations + logDetectedMigrations(this.currentVersions, this.dataMigrations, this.codeMigrations); + } + + public void runMigrations(Certificate certificate) { + + Map migrationsRan = new HashMap<>(); + + for (Entry entry : this.currentVersions.entrySet()) { + String realm = entry.getKey(); + Version currentVersion = entry.getValue(); + + logger.info("[" + realm + "] Performing all migrations after " + currentVersion); + + Version nextPossibleVersion = currentVersion.add(0, 0, 1); + CodeMigration currentCodeMigration = new CodeMigration(realm, nextPossibleVersion, null); + DataMigration currentDataMigration = new DataMigration(realm, nextPossibleVersion, null); + + if (!this.codeMigrations.isEmpty()) { + for (CodeMigration migration : this.codeMigrations.tailSet(currentCodeMigration)) { + migration.migrate(container, certificate); + migrationsRan.put(realm, migration.getVersion()); + } + } + + if (!this.dataMigrations.isEmpty()) { + for (DataMigration migration : this.dataMigrations.tailSet(currentDataMigration)) { + migration.migrate(container, certificate); + migrationsRan.put(realm, migration.getVersion()); + } + } + } + + this.migrationsRan = migrationsRan; + } + + private static void logDetectedMigrations(Map currentVersions, + SortedSet dataMigrations, SortedSet codeMigrations) { + for (Entry entry : currentVersions.entrySet()) { + String realm = entry.getKey(); + Version currentVersion = entry.getValue(); + + if (codeMigrations.isEmpty()) { + logger.info("[" + realm + "] Found no code migrations."); + } else { + logger.info("[" + realm + "] Found " + codeMigrations.size() + " code migrations"); + for (CodeMigration codeMigration : codeMigrations) { + if (codeMigration.getVersion().compareTo(currentVersion) > 0) + logger.info("[" + realm + "] + " + codeMigration.getVersion().toString()); + else + logger.info("[" + realm + "] - " + codeMigration.getVersion().toString()); + } + } + + if (dataMigrations.isEmpty()) { + logger.info("[" + realm + "] Found no data migrations."); + } else { + logger.info("[" + realm + "] Found " + dataMigrations.size() + " data migrations"); + for (DataMigration dataMigration : dataMigrations) { + if (dataMigration.getVersion().compareTo(currentVersion) > 0) + logger.info("[" + realm + "] + " + dataMigration.getVersion().toString()); + else + logger.info("[" + realm + "] - " + dataMigration.getVersion().toString()); + } + } + } + } + + private static SortedSet loadDataMigrations(Map currentVersions, File migrationsPath) { + + SortedSet dataMigrations = new TreeSet<>((o1, o2) -> o1.getVersion().compareTo(o2.getVersion())); + + File dataDir = new File(migrationsPath, "data"); + if (dataDir.exists()) { + DBC.PRE.assertTrue("migrations/data must be a directory!", dataDir.isDirectory()); + + File[] realmMigrations = dataDir.listFiles(); + for (File realmMigration : realmMigrations) { + + DBC.PRE.assertTrue("found non directory in migrations path: " + realmMigration.getAbsolutePath(), + realmMigration.isDirectory()); + String realm = realmMigration.getName(); + if (!currentVersions.containsKey(realm)) { + logger.warn("Found non realm migration directory: " + realmMigration.getAbsolutePath()); + continue; + } + + File[] migrations = realmMigration.listFiles((FileFilter) pathname -> pathname.getName().endsWith( + ".xml")); + for (File file : migrations) { + String name = file.getName(); + Version version = Version.valueOf(name.substring(0, name.length() - 4)); + dataMigrations.add(new DataMigration(realm, version, file)); + } + } + } + + return dataMigrations; + } + + private static SortedSet loadCodeMigrations(Map currentVersions, File migrationsPath) { + + SortedSet codeMigrations = new TreeSet<>((o1, o2) -> o1.getVersion().compareTo(o2.getVersion())); + + File codeDir = new File(migrationsPath, "code"); + if (codeDir.exists()) { + DBC.PRE.assertTrue("migrations/code must be a directory!", codeDir.isDirectory()); + + File[] realmMigrations = codeDir.listFiles(); + for (File realmMigration : realmMigrations) { + + DBC.PRE.assertTrue("found non directory in migrations path: " + realmMigration.getAbsolutePath(), + realmMigration.isDirectory()); + String realm = realmMigration.getName(); + if (!currentVersions.containsKey(realm)) { + logger.warn("Found non realm migration directory: " + realmMigration.getAbsolutePath()); + continue; + } + + File[] migrations = realmMigration.listFiles((FileFilter) pathname -> pathname.getName().endsWith( + ".xml")); + for (File file : migrations) { + String name = file.getName(); + Version version = Version.valueOf(name.substring(0, name.length() - 4)); + codeMigrations.add(new CodeMigration(realm, version, file)); + } + } + } + + return codeMigrations; + } + + public MapOfLists getMigrationsToRun() { + + MapOfLists migrationsToRun = new MapOfLists<>(); + + for (Entry entry : this.currentVersions.entrySet()) { + String realm = entry.getKey(); + Version nextPossibleVersion = entry.getValue().add(0, 0, 1); + CodeMigration currentCodeMigration = new CodeMigration(realm, nextPossibleVersion, null); + DataMigration currentDataMigration = new DataMigration(realm, nextPossibleVersion, null); + + SortedSet codeMigrations = this.codeMigrations.tailSet(currentCodeMigration); + for (CodeMigration codeMigration : codeMigrations) { + if (!migrationsToRun.containsElement(realm, codeMigration.getVersion())) + migrationsToRun.addElement(realm, codeMigration.getVersion()); + } + SortedSet dataMigrations = this.dataMigrations.tailSet(currentDataMigration); + for (DataMigration dataMigration : dataMigrations) { + if (!migrationsToRun.containsElement(realm, dataMigration.getVersion())) + migrationsToRun.addElement(realm, dataMigration.getVersion()); + } + } + + return migrationsToRun; + } +} diff --git a/li.strolch.agent/src/main/java/li/strolch/migrations/MigrationsHandler.java b/li.strolch.agent/src/main/java/li/strolch/migrations/MigrationsHandler.java new file mode 100644 index 000000000..c85333bb3 --- /dev/null +++ b/li.strolch.agent/src/main/java/li/strolch/migrations/MigrationsHandler.java @@ -0,0 +1,110 @@ +/* + * Copyright 2013 Robert von Burg + * + * 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 li.strolch.migrations; + +import java.io.File; +import java.util.HashMap; +import java.util.Map; + +import li.strolch.agent.api.ComponentContainer; +import li.strolch.agent.api.RealmHandler; +import li.strolch.agent.api.StrolchComponent; +import li.strolch.runtime.configuration.ComponentConfiguration; +import li.strolch.runtime.configuration.RuntimeConfiguration; +import li.strolch.runtime.privilege.PrivilegeHandler; +import ch.eitchnet.privilege.model.Certificate; +import ch.eitchnet.utils.Version; +import ch.eitchnet.utils.collections.MapOfLists; + +/** + * @author Robert von Burg + */ +public class MigrationsHandler extends StrolchComponent { + + private static final String PATH_MIGRATIONS = "migrations"; + + private Migrations migrations; + private Map lastMigrations; + private File migrationsPath; + + public MigrationsHandler(ComponentContainer container, String componentName) { + super(container, componentName); + } + + public Map getLastMigrations() { + return this.lastMigrations; + } + + public Map getCurrentVersions(Certificate cert) { + CurrentMigrationVersionQuery query = new CurrentMigrationVersionQuery(getContainer()); + query.doQuery(cert); + return query.getCurrentVersions(); + } + + public MapOfLists queryMigrationsToRun(Certificate cert) { + Map currentVersions = getCurrentVersions(cert); + Migrations migrations = new Migrations(getContainer(), currentVersions); + migrations.parseMigrations(this.migrationsPath); + + this.migrations = migrations; + return this.migrations.getMigrationsToRun(); + } + + public void runMigrations(Certificate cert) { + this.lastMigrations.clear(); + this.migrations.runMigrations(cert); + this.lastMigrations.putAll(this.migrations.getMigrationsRan()); + } + + @Override + public void initialize(ComponentConfiguration configuration) { + + this.lastMigrations = new HashMap<>(); + + RuntimeConfiguration runtimeConf = configuration.getRuntimeConfiguration(); + this.migrationsPath = runtimeConf.getDataDir(MigrationsHandler.class.getName(), PATH_MIGRATIONS, false); + if (this.migrationsPath.exists()) { + + CurrentMigrationVersionQuery query = new CurrentMigrationVersionQuery(getContainer()); + PrivilegeHandler privilegeHandler = getContainer().getComponent(PrivilegeHandler.class); + QueryCurrentVersionsAction action = new QueryCurrentVersionsAction(query); + privilegeHandler.runAsSystem(RealmHandler.SYSTEM_USER_AGENT, action); + Map currentVersions = query.getCurrentVersions(); + + Migrations migrations = new Migrations(getContainer(), currentVersions); + migrations.parseMigrations(this.migrationsPath); + + this.migrations = migrations; + } + + super.initialize(configuration); + } + + @Override + public void start() { + + if (this.migrations != null) { + + PrivilegeHandler privilegeHandler = getContainer().getComponent(PrivilegeHandler.class); + RunMigrationsAction action = new RunMigrationsAction(this.migrations); + + privilegeHandler.runAsSystem(RealmHandler.SYSTEM_USER_AGENT, action); + this.lastMigrations.putAll(this.migrations.getMigrationsRan()); + } + + super.start(); + } +} diff --git a/li.strolch.agent/src/main/java/li/strolch/migrations/QueryCurrentVersionsAction.java b/li.strolch.agent/src/main/java/li/strolch/migrations/QueryCurrentVersionsAction.java new file mode 100644 index 000000000..34b327a55 --- /dev/null +++ b/li.strolch.agent/src/main/java/li/strolch/migrations/QueryCurrentVersionsAction.java @@ -0,0 +1,39 @@ +/* + * Copyright 2013 Robert von Burg + * + * 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 li.strolch.migrations; + +import ch.eitchnet.privilege.handler.SystemUserAction; +import ch.eitchnet.privilege.model.PrivilegeContext; + +/** + * @author Robert von Burg + */ +public class QueryCurrentVersionsAction implements SystemUserAction { + + private CurrentMigrationVersionQuery query; + + /** + * @param container + */ + public QueryCurrentVersionsAction(CurrentMigrationVersionQuery query) { + this.query = query; + } + + @Override + public void execute(PrivilegeContext privilegeContext) { + this.query.doQuery(privilegeContext.getCertificate()); + } +} \ No newline at end of file diff --git a/li.strolch.agent/src/main/java/li/strolch/migrations/RunMigrationsAction.java b/li.strolch.agent/src/main/java/li/strolch/migrations/RunMigrationsAction.java new file mode 100644 index 000000000..ba8536963 --- /dev/null +++ b/li.strolch.agent/src/main/java/li/strolch/migrations/RunMigrationsAction.java @@ -0,0 +1,24 @@ +package li.strolch.migrations; + +import ch.eitchnet.privilege.handler.SystemUserAction; +import ch.eitchnet.privilege.model.PrivilegeContext; + +/** + * @author Robert von Burg + */ +public class RunMigrationsAction implements SystemUserAction { + + private Migrations migrations; + + /** + * @param migrations + */ + public RunMigrationsAction(Migrations migrations) { + this.migrations = migrations; + } + + @Override + public void execute(PrivilegeContext privilegeContext) { + this.migrations.runMigrations(privilegeContext.getCertificate()); + } +} diff --git a/li.strolch.agent/src/test/java/li/strolch/migrations/MigrationsTest.java b/li.strolch.agent/src/test/java/li/strolch/migrations/MigrationsTest.java new file mode 100644 index 000000000..dee004885 --- /dev/null +++ b/li.strolch.agent/src/test/java/li/strolch/migrations/MigrationsTest.java @@ -0,0 +1,47 @@ +package li.strolch.migrations; + +import static li.strolch.agent.ComponentContainerTest.destroyContainer; +import static li.strolch.agent.ComponentContainerTest.logger; +import static li.strolch.agent.ComponentContainerTest.startContainer; + +import java.util.Map; +import java.util.Map.Entry; + +import li.strolch.agent.api.StrolchAgent; +import li.strolch.runtime.privilege.PrivilegeHandler; + +import org.junit.Test; + +import ch.eitchnet.privilege.model.Certificate; +import ch.eitchnet.utils.Version; +import ch.eitchnet.utils.collections.MapOfLists; + +public class MigrationsTest { + + @Test + public void shouldRunMigrations() { + + try { + StrolchAgent agent = startContainer("target/MigrationsTest/", "src/test/resources/migrationstest"); + + PrivilegeHandler privilegeHandler = agent.getContainer().getPrivilegeHandler(); + Certificate cert = privilegeHandler.authenticate("test", "test".getBytes()); + + MigrationsHandler migrationsHandler = agent.getContainer().getComponent(MigrationsHandler.class); + Map currentVersions = migrationsHandler.getCurrentVersions(cert); + for (Entry entry : currentVersions.entrySet()) { + logger.info("[" + entry.getKey() + "] Current version: " + entry.getValue()); + } + + MapOfLists migrationsToRun = migrationsHandler.queryMigrationsToRun(cert); + for (String realm : migrationsToRun.keySet()) { + logger.info("[" + realm + "] Migrations to run: " + migrationsToRun.getList(realm)); + } + + destroyContainer(agent); + } catch (Exception e) { + logger.error(e.getMessage(), e); + throw e; + } + } +} diff --git a/li.strolch.agent/src/test/resources/migrationstest/config/PrivilegeConfig.xml b/li.strolch.agent/src/test/resources/migrationstest/config/PrivilegeConfig.xml new file mode 100644 index 000000000..9d7a227e3 --- /dev/null +++ b/li.strolch.agent/src/test/resources/migrationstest/config/PrivilegeConfig.xml @@ -0,0 +1,30 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/li.strolch.agent/src/test/resources/migrationstest/config/PrivilegeModel.xml b/li.strolch.agent/src/test/resources/migrationstest/config/PrivilegeModel.xml new file mode 100644 index 000000000..875b9c5af --- /dev/null +++ b/li.strolch.agent/src/test/resources/migrationstest/config/PrivilegeModel.xml @@ -0,0 +1,46 @@ + + + + + + SYSTEM + + agent + + + + Application + Administrator + ENABLED + en_GB + + PrivilegeAdmin + AppUser + + + + + + + + + true + + + true + + + true + + + + + true + + + true + + + + + \ No newline at end of file diff --git a/li.strolch.agent/src/test/resources/migrationstest/config/StrolchConfiguration.xml b/li.strolch.agent/src/test/resources/migrationstest/config/StrolchConfiguration.xml new file mode 100644 index 000000000..4ed2e74c8 --- /dev/null +++ b/li.strolch.agent/src/test/resources/migrationstest/config/StrolchConfiguration.xml @@ -0,0 +1,49 @@ + + + + + StrolchRuntimeTest + + TRANSIENT + true + + + + PrivilegeHandler + li.strolch.runtime.privilege.PrivilegeHandler + li.strolch.runtime.privilege.DefaultStrolchPrivilegeHandler + + PrivilegeConfig.xml + + + + RealmHandler + li.strolch.agent.api.RealmHandler + li.strolch.agent.impl.DefaultRealmHandler + PrivilegeHandler + + defaultRealm + TRANSIENT + Model.xml + + + + ServiceHandler + li.strolch.runtime.configuration.model.ServiceHandlerTest + li.strolch.runtime.configuration.model.ServiceHandlerTestImpl + RealmHandler + + + MigrationsHandler + li.strolch.migrations.MigrationsHandler + li.strolch.migrations.MigrationsHandler + ServiceHandler + + + PostInitializer + li.strolch.runtime.configuration.model.PostInitializerTest + li.strolch.runtime.configuration.model.PostInitializerTestImpl + MigrationsHandler + + + \ No newline at end of file diff --git a/li.strolch.agent/src/test/resources/migrationstest/data/Model.xml b/li.strolch.agent/src/test/resources/migrationstest/data/Model.xml new file mode 100644 index 000000000..58470ca2a --- /dev/null +++ b/li.strolch.agent/src/test/resources/migrationstest/data/Model.xml @@ -0,0 +1,26 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/li.strolch.agent/src/test/resources/migrationstest/data/migrations/data/defaultRealm/0.1.0.xml b/li.strolch.agent/src/test/resources/migrationstest/data/migrations/data/defaultRealm/0.1.0.xml new file mode 100644 index 000000000..e6259cb83 --- /dev/null +++ b/li.strolch.agent/src/test/resources/migrationstest/data/migrations/data/defaultRealm/0.1.0.xml @@ -0,0 +1,14 @@ + + + + + + + + + + + + + + diff --git a/li.strolch.agent/src/test/resources/migrationstest/data/migrations/data/defaultRealm/0.1.1.xml b/li.strolch.agent/src/test/resources/migrationstest/data/migrations/data/defaultRealm/0.1.1.xml new file mode 100644 index 000000000..e6259cb83 --- /dev/null +++ b/li.strolch.agent/src/test/resources/migrationstest/data/migrations/data/defaultRealm/0.1.1.xml @@ -0,0 +1,14 @@ + + + + + + + + + + + + + + diff --git a/li.strolch.agent/src/test/resources/migrationstest/data/migrations/data/defaultRealm/0.5.2.xml b/li.strolch.agent/src/test/resources/migrationstest/data/migrations/data/defaultRealm/0.5.2.xml new file mode 100644 index 000000000..e6259cb83 --- /dev/null +++ b/li.strolch.agent/src/test/resources/migrationstest/data/migrations/data/defaultRealm/0.5.2.xml @@ -0,0 +1,14 @@ + + + + + + + + + + + + + + diff --git a/li.strolch.agent/src/test/resources/migrationstest/data/migrations/data/defaultRealm/1.0.0.xml b/li.strolch.agent/src/test/resources/migrationstest/data/migrations/data/defaultRealm/1.0.0.xml new file mode 100644 index 000000000..e6259cb83 --- /dev/null +++ b/li.strolch.agent/src/test/resources/migrationstest/data/migrations/data/defaultRealm/1.0.0.xml @@ -0,0 +1,14 @@ + + + + + + + + + + + + + + diff --git a/li.strolch.agent/src/test/resources/migrationstest/data/migrations/data/defaultRealm/1.0.5.xml b/li.strolch.agent/src/test/resources/migrationstest/data/migrations/data/defaultRealm/1.0.5.xml new file mode 100644 index 000000000..e6259cb83 --- /dev/null +++ b/li.strolch.agent/src/test/resources/migrationstest/data/migrations/data/defaultRealm/1.0.5.xml @@ -0,0 +1,14 @@ + + + + + + + + + + + + + + diff --git a/li.strolch.agent/src/test/resources/migrationstest/data/migrations/data/defaultRealm/1.1.1.xml b/li.strolch.agent/src/test/resources/migrationstest/data/migrations/data/defaultRealm/1.1.1.xml new file mode 100644 index 000000000..e6259cb83 --- /dev/null +++ b/li.strolch.agent/src/test/resources/migrationstest/data/migrations/data/defaultRealm/1.1.1.xml @@ -0,0 +1,14 @@ + + + + + + + + + + + + + +