RoleRepositoryFileStore.java

/**
 *  Licensed to the Apache Software Foundation (ASF) under one or more
 *  contributor license agreements.  See the NOTICE file distributed with
 *  this work for additional information regarding copyright ownership.
 *  The ASF licenses this file to You 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 org.apache.felix.useradmin.filestore;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.Closeable;
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.OutputStream;
import java.util.Collections;
import java.util.Dictionary;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicReference;

import org.apache.felix.useradmin.RoleRepositoryStore;
import org.osgi.service.cm.ConfigurationException;
import org.osgi.service.cm.ManagedService;
import org.osgi.service.useradmin.UserAdminEvent;
import org.osgi.service.useradmin.UserAdminListener;


/**
 * Provides an implementation of {@link RoleRepositoryStore} using Java Serialization.
 */
public class RoleRepositoryFileStore extends RoleRepositoryMemoryStore implements Runnable, UserAdminListener, ManagedService {

    /** The PID for this service to allow its configuration to be updated. */
    public static final String PID = "org.apache.felix.useradmin.filestore";

    static final String KEY_WRITE_DISABLED = "background.write.disabled";
    static final String KEY_WRITE_DELAY_VALUE = "background.write.delay.value";
    static final String KEY_WRITE_DELAY_TIMEUNIT = "background.write.delay.timeunit";

    private static final String PREFIX = PID.concat(".");
    private static final boolean DEFAULT_WRITE_DISABLED = Boolean.parseBoolean(System.getProperty(PREFIX.concat(KEY_WRITE_DISABLED), "false"));
    private static final int DEFAULT_WRITE_DELAY_VALUE = Integer.parseInt(System.getProperty(PREFIX.concat(KEY_WRITE_DELAY_VALUE), "500"));
    private static final TimeUnit DEFAULT_WRITE_DELAY_TIMEUNIT = TimeUnit.MILLISECONDS;

    private static final String FILE_NAME = "ua_repo.dat";

    private final File m_file;
    private final AtomicReference m_timerRef;

    /**
     * Creates a new {@link RoleRepositoryStore} instance.
     * 
     * @param baseDir the base directory where we can store our serialized data, cannot be <code>null</code>.
     */
    public RoleRepositoryFileStore(File baseDir) {
        this(baseDir, !DEFAULT_WRITE_DISABLED);
    }
    
    /**
     * Creates a new {@link RoleRepositoryStore} instance.
     * 
     * @param baseDir the base directory where we can store our serialized data, cannot be <code>null</code>;
     * @param backgroundWriteEnabled <code>true</code> if background writing should be enabled, <code>false</code> to disable it. 
     */
    public RoleRepositoryFileStore(File baseDir, boolean backgroundWriteEnabled) {
        m_file = new File(baseDir, FILE_NAME);
        
        m_timerRef = new AtomicReference();

        if (backgroundWriteEnabled) {
            m_timerRef.set(new ResettableTimer(this, DEFAULT_WRITE_DELAY_VALUE, DEFAULT_WRITE_DELAY_TIMEUNIT));
        }
    }
    
    public void roleChanged(UserAdminEvent event) {
        scheduleTask();
    }

    /**
     * {@inheritDoc}
     * 
     * <p>Will be called by m_timer!</p>
     */
    public void run() {
        try {
            // Persist everything to disk...
            flush();
        }
        catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * Starts this store by reading the latest version from disk.
     * 
     * @throws IOException in case of I/O problems retrieving the store.
     */
    public void start() throws IOException {
        m_entries.putAll(retrieve());
    }

    /**
     * Stops this store service.
     */
    public void stop() throws IOException {
        ResettableTimer timer = (ResettableTimer) m_timerRef.get();
        if (timer != null) {
            if (!timer.isShutDown()) {
                // Shutdown and await termination...
                timer.shutDown();
            }
            // Clear reference...
            m_timerRef.compareAndSet(timer, null);
        }

        // Write the latest version to disk...
        flush();
    }

    /**
     * {@inheritDoc}
     */
    public void updated(Dictionary properties) throws ConfigurationException {
        boolean writeDisabled = DEFAULT_WRITE_DISABLED;
        int writeDelayValue = DEFAULT_WRITE_DELAY_VALUE;
        TimeUnit writeDelayUnit = DEFAULT_WRITE_DELAY_TIMEUNIT;

        if (properties != null) {
            Object wd = properties.get(KEY_WRITE_DISABLED);
            if (wd == null) {
                throw new ConfigurationException(KEY_WRITE_DISABLED, "Missing write disabled value!");
            }
            try {
                writeDisabled = Boolean.parseBoolean((String) wd);
            } catch (Exception e) {
                throw new ConfigurationException(KEY_WRITE_DISABLED, "Invalid write disabled value!");
            }

            if (!writeDisabled) {
                Object wdv = properties.get(KEY_WRITE_DELAY_VALUE);
                if (wdv == null) {
                    throw new ConfigurationException(KEY_WRITE_DELAY_VALUE, "Missing write delay value!");
                }
                try {
                    writeDelayValue = Integer.parseInt((String) wdv);
                } catch (Exception e) {
                    throw new ConfigurationException(KEY_WRITE_DELAY_VALUE, "Invalid write delay value!");
                }
                if (writeDelayValue <= 0) {
                    throw new ConfigurationException(KEY_WRITE_DELAY_VALUE, "Invalid write delay value!");
                }

                Object wdu = properties.get(KEY_WRITE_DELAY_TIMEUNIT);
                if (wdu != null) {
                    try {
                        writeDelayUnit = TimeUnit.valueOf(((String) wdu).toUpperCase());
                    } catch (Exception e) {
                        throw new ConfigurationException(KEY_WRITE_DELAY_TIMEUNIT, "Invalid write delay unit!");
                    }
                }
            }
        }

        ResettableTimer timer = (ResettableTimer) m_timerRef.get();
        if (timer != null) {
            timer.shutDown();
        }
        m_timerRef.compareAndSet(timer, writeDisabled ? null : new ResettableTimer(this, writeDelayValue, writeDelayUnit));
    }

    /**
     * Retrieves the serialized repository from disk.
     * 
     * @return the retrieved repository, never <code>null</code>.
     * @throws IOException in case the retrieval of the repository failed.
     */
    protected Map retrieve() throws IOException {
        InputStream is = null;

        try {
            is = new BufferedInputStream(new FileInputStream(m_file));

            return new RoleRepositorySerializer().deserialize(is);
        } catch (FileNotFoundException exception) {
            // Don't bother; file does not exist...
            return Collections.emptyMap();
        } catch (IOException exception) {
            exception.printStackTrace();
            throw exception;
        } finally {
            closeSafely(is);
        }
    }

    /**
     * Stores the given repository to disk as serialized objects.
     * 
     * @param roleRepository the repository to store, cannot be <code>null</code>.
     * @throws IOException in case storing the repository failed.
     */
    protected void store(Map roleRepository) throws IOException {
        OutputStream os = null;

        try {
            os = new BufferedOutputStream(new FileOutputStream(m_file));

            new RoleRepositorySerializer().serialize(roleRepository, os);
        } finally {
            closeSafely(os);
        }
    }

    /**
     * Closes a given resource, ignoring any exceptions that may come out of this.
     * 
     * @param resource the resource to close, can be <code>null</code>.
     */
    private void closeSafely(Closeable resource) {
        if (resource != null) {
            try {
                resource.close();
            } catch (IOException e) {
                // Ignore
            }
        }
    }

    /**
     * Flushes the current repository to disk.
     * 
     * @throws IOException in case of problems storing the repository.
     */
    private void flush() throws IOException {
        store(new HashMap(m_entries));
    }

    /**
     * Notifies the background timer to schedule a task for storing the 
     * contents of this store to disk.
     */
    private void scheduleTask() {
        ResettableTimer timer = (ResettableTimer) m_timerRef.get();
        if (timer != null && !timer.isShutDown()) {
            timer.schedule();
        }
    }
}