db4ocontroller.java

lucene2.2.0版本

/**
 * 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.lucene.gdata.storage.db4o;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;
import java.security.NoSuchAlgorithmException;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.lucene.gdata.data.GDataAccount;
import org.apache.lucene.gdata.data.ServerBaseFeed;
import org.apache.lucene.gdata.server.registry.Component;
import org.apache.lucene.gdata.server.registry.ComponentType;
import org.apache.lucene.gdata.server.registry.Scope;
import org.apache.lucene.gdata.server.registry.ScopeVisitor;
import org.apache.lucene.gdata.server.registry.configuration.Requiered;
import org.apache.lucene.gdata.storage.IDGenerator;
import org.apache.lucene.gdata.storage.Storage;
import org.apache.lucene.gdata.storage.StorageController;
import org.apache.lucene.gdata.storage.StorageException;
import org.apache.lucene.gdata.storage.db4o.DB4oStorage.DB4oEntry;
import org.apache.lucene.gdata.utils.Pool;
import org.apache.lucene.gdata.utils.PoolObjectFactory;
import org.apache.lucene.gdata.utils.SimpleObjectPool;

import com.db4o.Db4o;
import com.db4o.ObjectContainer;
import com.db4o.ObjectServer;
import com.google.gdata.data.BaseEntry;
import com.google.gdata.data.BaseFeed;

/**
 * The DB4o StorageContorller can be used as a persitence component for the
 * gdata-server. To use DB4o a third party jar needs to added to the lib
 * directory of the project. If the jar is not available in the lib directory
 * all db4o dependent class won't be included in the build.
 * <p>
 * If the jar is present in the lib directory this class can be configured as a
 * {@link org.apache.lucene.gdata.server.registry.ComponentType#STORAGECONTROLLER}
 * via the <i>gdata-config.xml</i> file. For detailed config documentation see
 * the wiki page.
 * </p>
 * <p>
 * The DB4oController can run as a client or as a server to serve other running
 * db4o clients in the network. To achive the best performance out of the db4o
 * caching layer connections to the server will be reused in a connection pool.
 * A connection will not be shared withing more than one thread. The controller
 * release one connection per request and returns the connection when the
 * request has been destroyed.
 * </p>
 * @see <a href="http://www.db4o.com">db4o website</a>
 * @see org.apache.lucene.gdata.utils.Pool
 * 
 * 
 * @author Simon Willnauer
 * 
 */
@Component(componentType = ComponentType.STORAGECONTROLLER)
@Scope(scope = Scope.ScopeType.REQUEST)
public class DB4oController implements StorageController, ScopeVisitor {
    private static final Log LOG = LogFactory.getLog(DB4oController.class);

    private final ThreadLocal<Storage> threadLocalStorage = new ThreadLocal<Storage>();

    private Pool<ObjectContainer> containerPool;

    private ObjectServer server;

    private final IDGenerator idGenerator;

    private boolean weakReferences;

    private boolean runAsServer;

    private int port;

    private String filePath;

    private String user;

    private String password;

    private String host;

    private int containerPoolSize;

    /**
     * @throws NoSuchAlgorithmException
     * 
     */
    public DB4oController() throws NoSuchAlgorithmException {

        this.idGenerator = new IDGenerator(15);

    }

    ObjectContainer releaseContainer() {
        return this.server.openClient();

    }

    /**
     * @see org.apache.lucene.gdata.storage.StorageController#destroy()
     */
    public void destroy() {
        this.containerPool.destroy();
        this.idGenerator.stopIDGenerator();
        this.server.close();
    }

    /**
     * @see org.apache.lucene.gdata.storage.StorageController#getStorage()
     */
    public Storage getStorage() throws StorageException {
       Storage retVal = this.threadLocalStorage.get();
        if (retVal != null)
            return retVal;

        retVal = new DB4oStorage(this.containerPool.aquire(), this);

        this.threadLocalStorage.set(retVal);
        return retVal;
    }

    /**
     * @see org.apache.lucene.gdata.server.registry.ServerComponent#initialize()
     */
    public void initialize() {
        if (LOG.isInfoEnabled())
            LOG.info("Initialize " + this.toString());

        Db4o.configure().objectClass(DB4oEntry.class).objectField("updated")
                .indexed(true);
        Db4o.configure().objectClass(BaseEntry.class).objectField("id")
                .indexed(true);
        Db4o.configure().objectClass(BaseFeed.class).objectField("id").indexed(
                true);
        Db4o.configure().objectClass(GDataAccount.class).objectField("name")
                .indexed(true);
        Db4o.configure().objectClass(ServerBaseFeed.class).cascadeOnDelete(
                false);
        Db4o.configure().objectClass(ServerBaseFeed.class)
                .maximumActivationDepth(0);
        Db4o.configure().objectClass(BaseFeed.class).minimumActivationDepth(1);
        Db4o.configure().objectClass(BaseEntry.class)
                .minimumActivationDepth(1);
        Db4o.configure().objectClass(BaseFeed.class).cascadeOnDelete(true);
        Db4o.configure().objectClass(DB4oEntry.class).cascadeOnDelete(true);
        Db4o.configure().objectClass(GDataAccount.class).cascadeOnDelete(true);
        Db4o.configure().weakReferences(this.weakReferences);
        Db4o.configure().optimizeNativeQueries(false);
        if (this.runAsServer) {
            this.server = Db4o.openServer(this.filePath, this.port);
            if(this.server == null)
                throw new RuntimeException("Can't create server at confiugred destination -- "+this.filePath);
            this.server.grantAccess(this.user, this.password);
        } else {
            InvocationHandler handler = new ObjectServerDecorator(this.user,
                    this.password, this.host, this.port);
            this.server = (ObjectServer) Proxy.newProxyInstance(this.getClass()
                    .getClassLoader(), new Class[] { ObjectServer.class },
                    handler);
        }

        PoolObjectFactory<ObjectContainer> factory = new ObjectContinerFactory(
                this.server);
        this.containerPool = new SimpleObjectPool<ObjectContainer>(
                this.containerPoolSize, factory);
        try {
            createAdminAccount();
        } catch (StorageException e) {
            LOG.error("Can not create admin account -- ",e);
        }
    }

    private void createAdminAccount() throws StorageException {
        GDataAccount adminAccount = GDataAccount.createAdminAccount();
        visiteInitialize();
        Storage sto = this.getStorage();
        try {
            sto.getAccount(adminAccount.getName());
        } catch (Exception e) {
            this.getStorage().storeAccount(adminAccount);
        } finally {
            visiteDestroy();
        }

    }

    
    /**
     * @see org.apache.lucene.gdata.storage.StorageController#releaseId()
     */
    public String releaseId(){
        try{
        return this.idGenerator.getUID();
        }catch (InterruptedException e) {
            throw new StorageException("ID producer has been interrupted",e);
        }
    }

    /**
     * @see org.apache.lucene.gdata.server.registry.ScopeVisitor#visiteInitialize()
     */
    public void visiteInitialize() {
        if (LOG.isInfoEnabled())
            LOG.info("Opened Storage -- request initialized");
        Storage storage = this.threadLocalStorage.get();
        if (storage != null) {
            LOG.warn("Storage already opened");
            return;
        }

        storage = new DB4oStorage(this.containerPool.aquire(), this);

        this.threadLocalStorage.set(storage);
    }

    /**
     * @see org.apache.lucene.gdata.server.registry.ScopeVisitor#visiteDestroy()
     */
    public void visiteDestroy() {
        Storage storage = this.threadLocalStorage.get();
        if (storage == null) {
            LOG.warn("no Storage opened -- threadlocal returned null");
            return;
        }
        this.containerPool.release(((DB4oStorage)storage).getContainer());
        this.threadLocalStorage.remove();
        if (LOG.isInfoEnabled())
            LOG.info("Closed Storage -- request destroyed");
    }

    private static class ObjectContinerFactory implements
            PoolObjectFactory<ObjectContainer> {
        private final ObjectServer server;

        ObjectContinerFactory(final ObjectServer server) {
            this.server = server;
        }

        /**
         * @see org.apache.lucene.gdata.utils.PoolObjectFactory#getInstance()
         */
        public ObjectContainer getInstance() {

            return this.server.openClient();
        }

        /**
         * @param type -
         *            object container to destroy (close)
         * @see org.apache.lucene.gdata.utils.PoolObjectFactory#destroyInstance(Object)
         */
        public void destroyInstance(ObjectContainer type) {
            type.close();
        }

    }

    /**
     * @return Returns the filePath.
     */
    public String getFilePath() {
        return this.filePath;
    }

    /**
     * @param filePath
     *            The filePath to set.
     */
    public void setFilePath(String filePath) {
        this.filePath = filePath;
    }

    /**
     * @return Returns the host.
     */
    public String getHost() {
        return this.host;
    }

    /**
     * @param host
     *            The host to set.
     */
    @Requiered
    public void setHost(String host) {
        this.host = host;
    }

    /**
     * @return Returns the password.
     */
    public String getPassword() {
        return this.password;
    }

    /**
     * @param password
     *            The password to set.
     */
    @Requiered
    public void setPassword(String password) {
        this.password = password;
    }

    /**
     * @return Returns the port.
     */
    public int getPort() {
        return this.port;
    }

    /**
     * @param port
     *            The port to set.
     */
    @Requiered
    public void setPort(int port) {
        this.port = port;
    }

    /**
     * @return Returns the runAsServer.
     */
    public boolean isRunAsServer() {
        return this.runAsServer;
    }

    /**
     * @param runAsServer
     *            The runAsServer to set.
     */
    @Requiered
    public void setRunAsServer(boolean runAsServer) {
        this.runAsServer = runAsServer;
    }

    /**
     * @return Returns the user.
     */
    public String getUser() {
        return this.user;
    }

    /**
     * @param user
     *            The user to set.
     */
    @Requiered
    public void setUser(String user) {
        this.user = user;
    }

    /**
     * @return Returns the weakReferences.
     */
    public boolean isUseWeakReferences() {
        return this.weakReferences;
    }

    /**
     * @param weakReferences
     *            The weakReferences to set.
     */
    @Requiered
    public void setUseWeakReferences(boolean weakReferences) {
        this.weakReferences = weakReferences;
    }

    /**
     * @return Returns the containerPoolSize.
     */
    public int getContainerPoolSize() {
        return this.containerPoolSize;
    }

    /**
     * @param containerPoolSize
     *            The containerPoolSize to set.
     */
    @Requiered
    public void setContainerPoolSize(int containerPoolSize) {
        this.containerPoolSize = containerPoolSize < 1 ? 1 : containerPoolSize;
    }

    /**
     * @see java.lang.Object#toString()
     */
    @Override
    public String toString() {
        StringBuilder builder = new StringBuilder(this.getClass().getName())
                .append(" ");
        builder.append("host: ").append(this.host).append(" ");
        builder.append("port: ").append(this.port).append(" ");
        builder.append("pool size: ").append(this.containerPoolSize)
                .append(" ");
        builder.append("runs as server: ").append(this.runAsServer).append(" ");
        builder.append("use weak references: ").append(this.weakReferences)
                .append(" ");
        builder.append("user: ").append(this.user).append(" ");
        builder.append("password length: ").append(
                this.password == null ? "no password" : this.password.length())
                .append(" ");

        return builder.toString();
    }

}