MapsIndexer.java

Go to the documentation of this file.

/*
 * Gridarta MMORPG map editor for Crossfire, Daimonin and similar games.
 * Copyright (C) 2000-2023 The Gridarta Developers.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program; if not, write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */
 
package net.sf.gridarta.model.index;
 
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.OutputStream;
import java.nio.charset.StandardCharsets;
import java.util.Arrays;
import java.util.concurrent.Semaphore;
import net.sf.gridarta.model.archetype.Archetype;
import net.sf.gridarta.model.gameobject.GameObject;
import net.sf.gridarta.model.maparchobject.MapArchObject;
import net.sf.gridarta.model.mapcontrol.DefaultMapControl;
import net.sf.gridarta.model.mapcontrol.MapControl;
import net.sf.gridarta.model.mapcontrol.MapControlListener;
import net.sf.gridarta.model.mapmanager.MapManager;
import net.sf.gridarta.model.mapmanager.MapManagerListener;
import net.sf.gridarta.model.mapmodel.MapFile;
import net.sf.gridarta.model.settings.ProjectSettings;
import net.sf.gridarta.model.settings.ProjectSettingsListener;
import net.sf.gridarta.utils.ConfigFileUtils;
import net.sf.gridarta.utils.Xtea;
import org.apache.log4j.Category;
import org.apache.log4j.Logger;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
 
public class MapsIndexer<G extends GameObject<G, A, R>, A extends MapArchObject<A>, R extends Archetype<G, A, R>> {
 
    @NotNull
    private static final Category LOG = Logger.getLogger(MapsIndexer.class);
 
    @NotNull
    private final Semaphore mapsIndexSemaphore = new Semaphore(1);
 
    @NotNull
    private final MapsIndex mapsIndex;
 
    @NotNull
    private final MapManager<G, A, R> mapManager;
 
    @NotNull
    private final ProjectSettings projectSettings;
 
    @NotNull
    private final Object syncMapsDirectory = new Object();
 
    @Nullable
    private File mapsDirectory;
 
    @Nullable
    private File newMapsDirectory;
 
    @NotNull
    private final Object syncState = new Object();
 
    @NotNull
    private State state = State.INIT;
 
    private enum State {
 
        INIT,
 
        SCAN,
 
        INDEX,
 
        IDLE
 
    }
 
    @NotNull
    private final MapManagerListener<G, A, R> mapManagerListener = new MapManagerListener<G, A, R>() {
 
        @Override
        public void currentMapChanged(@Nullable final MapControl<G, A, R> mapControl) {
            // ignore
        }
 
        @Override
        public void mapCreated(@NotNull final MapControl<G, A, R> mapControl, final boolean interactive) {
            if (!mapControl.isPickmap()) {
                mapControl.addMapControlListener(mapControlListener);
            }
        }
 
        @Override
        public void mapClosing(@NotNull final MapControl<G, A, R> mapControl) {
            // ignore
        }
 
        @Override
        public void mapClosed(@NotNull final MapControl<G, A, R> mapControl) {
            if (!mapControl.isPickmap()) {
                mapControl.removeMapControlListener(mapControlListener);
            }
        }
 
    };
 
    @NotNull
    private final MapControlListener<G, A, R> mapControlListener = new MapControlListener<G, A, R>() {
 
        @Override
        public void saved(@NotNull final DefaultMapControl<G, A, R> mapControl) {
            final MapFile mapFile = mapControl.getMapModel().getMapFile();
            if (mapFile != null) {
                mapsIndex.setPending(mapFile);
            }
        }
 
    };
 
    @NotNull
    private final ProjectSettingsListener projectSettingsListener = new ProjectSettingsListener() {
 
        @Override
        public void mapsDirectoryChanged(@NotNull final File mapsDirectory) {
            synchronized (syncMapsDirectory) {
                newMapsDirectory = projectSettings.getMapsDirectory();
            }
        }
 
    };
 
    @NotNull
    private final IndexListener<MapFile> indexListener = new IndexListener<MapFile>() {
 
        @Override
        public void valueAdded(@NotNull final MapFile value) {
            // ignore
        }
 
        @Override
        public void valueRemoved(@NotNull final MapFile value) {
            // ignore
        }
 
        @Override
        public void nameChanged() {
            // ignore
        }
 
        @Override
        public void pendingChanged() {
            mapsIndexSemaphore.release();
        }
 
        @Override
        public void indexingFinished() {
            // ignore
        }
 
    };
 
    @NotNull
    private final Runnable runnable = () -> {
        while (!Thread.currentThread().isInterrupted()) {
            updateMapsDirectory();
            indexPendingMaps();
            if (state == State.IDLE) {
                try {
                    mapsIndexSemaphore.acquire();
                } catch (final InterruptedException ignored) {
                    Thread.currentThread().interrupt();
                    break;
                }
            }
        }
    };
 
    @NotNull
    private final Thread thread = new Thread(runnable, "indexer");
 
    public MapsIndexer(@NotNull final MapsIndex mapsIndex, @NotNull final MapManager<G, A, R> mapManager, @NotNull final ProjectSettings projectSettings) {
        this.mapsIndex = mapsIndex;
        this.mapManager = mapManager;
        this.projectSettings = projectSettings;
        reportStateChange();
    }
 
    public void start() {
        projectSettings.addProjectSettingsListener(projectSettingsListener);
        mapManager.addMapManagerListener(mapManagerListener);
        synchronized (syncMapsDirectory) {
            newMapsDirectory = projectSettings.getMapsDirectory();
        }
        mapsIndex.addIndexListener(indexListener);
        thread.start();
    }
 
    public void stop() throws InterruptedException {
        try {
            thread.interrupt();
            thread.join();
        } finally {
            projectSettings.removeProjectSettingsListener(projectSettingsListener);
            mapManager.removeMapManagerListener(mapManagerListener);
            for (final MapControl<G, A, R> mapControl : mapManager.getOpenedMaps()) {
                if (!mapControl.isPickmap()) {
                    mapControl.removeMapControlListener(mapControlListener);
                }
            }
            mapsIndex.removeIndexListener(indexListener);
        }
 
        synchronized (syncMapsDirectory) {
            saveMapsIndex();
        }
    }
 
    public void waitForIdle() throws InterruptedException {
        synchronized (syncState) {
            while (state != State.IDLE || mapsIndex.hasPending()) {
                syncState.wait(1000L);
            }
        }
    }
 
    private void updateMapsDirectory() {
        final File tmpMapsDirectory;
        synchronized (syncMapsDirectory) {
            if (newMapsDirectory == null || (mapsDirectory != null && mapsDirectory.equals(newMapsDirectory))) {
                return;
            }
 
            setState(State.SCAN);
 
            saveMapsIndex();
 
            tmpMapsDirectory = newMapsDirectory;
            assert tmpMapsDirectory != null;
            mapsDirectory = tmpMapsDirectory;
            newMapsDirectory = null;
 
            loadMapsIndex();
        }
        mapsIndex.beginUpdate();
        scanMapsDirectoryInt(new MapFile(tmpMapsDirectory), "");
        mapsIndex.endUpdate();
    }
 
    private void saveMapsIndex() {
        assert Thread.holdsLock(syncMapsDirectory);
        if (mapsDirectory == null) {
            return;
        }
 
        if (!projectSettings.saveIndices()) {
            return;
        }
 
        if (!mapsIndex.isModified()) {
            return;
        }
 
        assert mapsDirectory != null;
        final File cacheFile = getCacheFile(mapsDirectory);
        try {
            try (OutputStream outputStream = new FileOutputStream(cacheFile)) {
                try (ObjectOutputStream objectOutputStream = new ObjectOutputStream(outputStream)) {
                    mapsIndex.save(objectOutputStream);
                }
            }
            if (LOG.isInfoEnabled()) {
                LOG.info(cacheFile + ": saved " + mapsIndex.size() + " entries");
            }
        } catch (final IOException ex) {
            LOG.warn(cacheFile + ": cannot save cache file: " + ex.getMessage());
        }
    }
 
    private void loadMapsIndex() {
        assert Thread.holdsLock(syncMapsDirectory);
        assert mapsDirectory != null;
        final File cacheFile = getCacheFile(mapsDirectory);
        try {
            try (InputStream inputStream = new FileInputStream(cacheFile)) {
                try (ObjectInputStream objectInputStream = new ObjectInputStream(inputStream)) {
                    mapsIndex.load(objectInputStream);
                }
            }
            if (LOG.isInfoEnabled()) {
                LOG.info(cacheFile + ": loaded " + mapsIndex.size() + " entries");
            }
        } catch (final FileNotFoundException ex) {
            if (LOG.isDebugEnabled()) {
                LOG.debug(cacheFile + ": cache file does not exist: " + ex.getMessage());
            }
            mapsIndex.clear();
        } catch (final IOException ex) {
            LOG.warn(cacheFile + ": cannot load cache file: " + ex.getMessage());
            mapsIndex.clear();
        }
    }
 
    private void scanMapsDirectoryInt(@NotNull final MapFile dir, @NotNull final String mapPath) {
        final File[] files = dir.getFile().listFiles();
        if (files == null) {
            return;
        }
 
        for (final File file : files) {
            final MapFile mapFile = new MapFile(dir, file.getName());
            if (file.isFile() && !file.getName().endsWith("~")) {
                mapsIndex.add(mapFile, file.lastModified());
            } else if (file.isDirectory() && !file.getName().equalsIgnoreCase(".svn") && !file.getName().equalsIgnoreCase(".dedit")) {
                scanMapsDirectoryInt(mapFile, mapPath + "/" + file.getName());
            }
        }
    }
 
    private void indexPendingMaps() {
        final MapFile mapFile = mapsIndex.removePending();
        if (mapFile == null) {
            setState(State.IDLE);
            return;
        }
 
        setState(State.INDEX);
        final long timestamp = mapFile.getFile().lastModified();
        final MapControl<G, A, R> mapControl;
        try {
            mapControl = mapManager.openMapFile(mapFile, false);
        } catch (final IOException ex) {
            if (LOG.isInfoEnabled()) {
                LOG.info(mapFile + ": load failed:" + ex.getMessage());
            }
            return;
        }
        try {
            final String mapName = mapControl.getMapModel().getMapArchObject().getMapName();
            if (LOG.isDebugEnabled()) {
                LOG.debug(mapFile + ": indexing as '" + mapName + "'");
            }
            mapsIndex.setName(mapFile, timestamp, mapName);
        } finally {
            mapManager.release(mapControl);
        }
    }
 
    @NotNull
    private static File getCacheFile(@NotNull final File mapsDirectory) {
        final byte[] key = new byte[16];
        final Xtea xtea = new Xtea(key);
        final byte[] data = mapsDirectory.getAbsoluteFile().toString().getBytes(StandardCharsets.UTF_8);
        final byte[] hash = new byte[8];
        final byte[] in = new byte[8];
        final byte[] out = new byte[8];
        int i;
        for (i = 0; i + 8 < data.length; i++) {
            System.arraycopy(data, i, in, 0, 8);
            xtea.encrypt(in, out);
            for (int j = 0; j < 8; j++) {
                hash[j] ^= out[j];
            }
        }
        final int len = data.length % 8;
        System.arraycopy(data, i, in, 0, len);
        in[len] = 1;
        Arrays.fill(in, len + 1, 8, (byte) 0);
        xtea.encrypt(in, out);
        for (int j = 0; j < 8; j++) {
            hash[j] ^= out[j];
        }
 
        final StringBuilder sb = new StringBuilder("index/maps/");
        for (int j = 0; j < 8; j++) {
            sb.append(String.format("%02x", hash[j] & 0xff));
        }
        sb.append(mapsDirectory.getName());
        final File file = ConfigFileUtils.getHomeFile(sb.toString());
        final File dir = file.getParentFile();
        if (dir != null && !dir.exists() && !dir.mkdirs()) {
            LOG.warn("cannot create directory: " + dir);
        }
        return file;
    }
 
    private void setState(@NotNull final State state) {
        synchronized (syncState) {
            if (this.state == state) {
                return;
            }
 
            this.state = state;
            reportStateChange();
            syncState.notifyAll();
        }
    }
 
    private void reportStateChange() {
        if (LOG.isDebugEnabled()) {
            LOG.debug("state=" + state);
        }
 
        if (state == State.IDLE) {
            mapsIndex.indexingFinished();
        }
    }
 
}