Backup von Indices

Werden in eigenen Bundles Elasticsearch Indices angelegt, dann möchte man von diesen evtl. auch Sicherheitskopien erstellen. Dies kann über den BackupManager Dienst vom BPC Core realisiert werden.

Dies bietet folgende Vorteile

es wird einiges an Boilerplate Code vermieden
kann so konfiguriert werden, dass periodisch diese Backups angelegt werden

In Kürze

im eigenen Bundle/Modul wird ein spezifisches Backup Setting eingeführt, so daß diese über das BPC Frontend angepasst werden kann
die zu sichernden Indices werden dem BackupManager Dienst mitgeteilt, welcher dann die Backups durchführt

Modulspezifische Backupeinstellung

Die Backupfunktionalität benötigt ein paar Informationen zur Ausführung der Sicherheitskopien. Dies wird über eine JSON basierte Setting zur Verfügung gestellt und hat folgenden Aufbau in dem Beispiel unten hat diese Setting den Namen indicesBackup:

{
  "enabled": true,
  "intervalInSeconds": 86400,
  "keepBackupsDurationInSeconds": 7776000
}

enabled - true|false je nachdem ob die Backups ausgeführt werden sollen oder nicht
intervalInSeconds - das Intervall in Sekunden in denen die Backups durchgeführt werden sollen. Bei einem Intervall von 86400 Sekunden wird alle 24 Stunden ein Backup der Indices angelegt.
keepBackupsDurationInSeconds - legt fest wie lange die Backups vorgehalten werden sollen. Bei einer festgelegten Dauer von 7776000 Sekunden werden Backups die älter als 90 Tage sind gelöscht.

Umsetzung

In dem folgenden ExampleBaseModule.java Beispiel werden die drei Indices dein-index-name-1, dein-index-name-2 und dein-index-name-3 dem BackupManager Dienst des BPC Core als zu sichernde Indices mitgeteilt.

Die Registrierung der zu sichernden Indices mit deinen spezifischen Backupeinstellungen geschieht sobald der BackupManager Dienst zur Verfügung steht und wenn sich deine Backupeinstellungen geändert haben.

ExampleBaseModule.java

package com.company.example;

import de.virtimo.bpc.api.*;
import de.virtimo.bpc.core.utils.DictionaryUtil;
import de.virtimo.bpc.module.AbstractInstantiableModule;
import org.osgi.framework.Bundle;
import org.osgi.framework.BundleContext;
import org.osgi.framework.ServiceReference;
import org.osgi.framework.ServiceRegistration;
import org.osgi.service.event.Event;
import org.osgi.service.event.EventConstants;
import org.osgi.service.event.EventHandler;
import org.osgi.util.tracker.ServiceTracker;

import java.util.List;
import java.util.logging.Logger;

public abstract class ExampleBaseModule extends AbstractInstantiableModule {
    private static final Logger LOG = Logger.getLogger(ExampleBaseModule.class.getName());

    public static final String SETTING_INDICES_BACKUP = "indicesBackup";

    private ServiceRegistration myModuleLoadedEventHandler;
    private ServiceRegistration myModuleUpdatedEventHandler;

    private ServiceTracker backupManagerTracker;
    private BackupManager backupManager;

    public ExampleBaseModule(ModuleManager moduleManager) {
        super(moduleManager);
    }

    @Override
    public void setModuleBundle(Bundle moduleBundle) {
        super.setModuleBundle(moduleBundle);

        // Event Handler der aufgerufen wird, nachdem der BPC Core dein Modul geladen hat
        if (myModuleLoadedEventHandler == null) {
            myModuleLoadedEventHandler = moduleBundle.getBundleContext().registerService(EventHandler.class.getName(), new MyModuleLoadedEventHandler(), DictionaryUtil.dictionaryOf(
                    EventConstants.EVENT_TOPIC, new String[]{"de/virtimo/bpc/core/backendModuleLoaded"},
                    EventConstants.EVENT_FILTER, "(moduleId=" + getModuleId() + ")")
            );
        }

        // Event Handler der aufgerufen wird, wenn sich ein Setting deines Moduls geändert hat
        if (myModuleUpdatedEventHandler == null) {
            myModuleUpdatedEventHandler = moduleBundle.getBundleContext().registerService(EventHandler.class.getName(), new MyModuleUpdatedEventHandler(), DictionaryUtil.dictionaryOf(
                    EventConstants.EVENT_TOPIC, new String[]{"de/virtimo/bpc/core/Configuration/moduleUpdated"},
                    EventConstants.EVENT_FILTER, "(&(moduleId=" + getModuleId() + ")(moduleInstanceId=" + ModuleConfiguration.NO_INSTANCE_ID + "))")
            );
        }
    }

    @Override
    public void destroy() {
        super.destroy();

        if (backupManagerTracker != null) {
            backupManagerTracker.close();
            backupManagerTracker = null;
        }
    }

    private BackupSetting getBackupSetting(Setting setting) {
        return BackupSetting.buildFrom(setting, new String[]{
                "dein-index-name-1",
                "dein-index-name-2",
                "dein-index-name-3"
        });
    }

    private class MyModuleLoadedEventHandler implements EventHandler {
        @Override
        public void handleEvent(Event event) {
            if (backupManagerTracker == null) {
                backupManagerTracker = new BackupManagerTracker(getModuleBundle().getBundleContext());
                backupManagerTracker.open();
            }
        }
    }

    private class MyModuleUpdatedEventHandler implements EventHandler {
        @Override
        public void handleEvent(Event event) {
            Object settingsListObject = event.getProperty("setting");
            if (settingsListObject instanceof List) {
                for (Setting updatedSetting : (List<Setting>) settingsListObject) {
                    // backup setting updated => restart backup job
                    if (SETTING_INDICES_BACKUP.equals(updatedSetting.getName())) {
                        if (backupManager != null) {
                            backupManager.scheduleBackupJobWithSettings(getModuleId(), getBackupSetting(updatedSetting));
                        }
                    }
                }
            }
        }
    }

    private class BackupManagerTracker extends ServiceTracker {
        public BackupManagerTracker(BundleContext context) {
            super(context, BackupManager.class.getName(), null);
        }

        @Override
        public Object addingService(ServiceReference reference) {
            backupManager = (BackupManager) context.getService(reference);
            BackupSetting backupSetting = getBackupSetting(getConfiguration().getSetting(SETTING_INDICES_BACKUP));
            backupManager.scheduleBackupJobWithSettings(getModuleId(), backupSetting);
            return backupManager;
        }

        @Override
        public void removedService(ServiceReference reference, Object service) {
            backupManager.stopBackupJob(getModuleId());
            backupManager = null;
            context.ungetService(reference);
        }
    }
}

Keywords: