path: root/java/src/Freeze/ObjectStore.java

// **********************************************************************
//
// Copyright (c) 2003-2007 ZeroC, Inc. All rights reserved.
//
// This copy of Ice is licensed to you under the terms described in the
// ICE_LICENSE file included in this distribution.
//
// **********************************************************************

package Freeze;

class ObjectStore implements IceUtil.Store
{
    
    ObjectStore(String facet, boolean createDb, EvictorI evictor, 
		java.util.List indices, boolean populateEmptyIndices)
    {
	_cache = new IceUtil.Cache(this);
	
	_facet = facet;
	_evictor = evictor;
	_indices = indices;
	_communicator = evictor.communicator();
	
	if(facet.equals(""))
	{
	    _dbName = EvictorI.defaultDb;
	}
	else
	{
	    _dbName = facet;
	}

	Connection connection = Util.createConnection(_communicator, evictor.dbEnv().getEnvName());

	try
	{
	    Catalog catalog = new Catalog(connection, Util.catalogName(), true);	    
	    CatalogData catalogData = (CatalogData)catalog.get(evictor.filename());
	    
	    if(catalogData != null && catalogData.evictor == false)
	    {
		DatabaseException ex = new DatabaseException();
		ex.message = _evictor.errorPrefix() + evictor.filename() + " is not an evictor database";
		throw ex;
	    }
	    
	    com.sleepycat.db.Environment dbEnv = evictor.dbEnv().getEnv();
	    
	    try
	    {	    
		Transaction tx = connection.beginTransaction();
		com.sleepycat.db.Transaction txn = Util.getTxn(tx);

		//
		// TODO: FREEZE_DB_MODE
		//
		com.sleepycat.db.DatabaseConfig config = new com.sleepycat.db.DatabaseConfig();
		config.setType(com.sleepycat.db.DatabaseType.BTREE);
		config.setAllowCreate(createDb);
		_db = dbEnv.openDatabase(txn, evictor.filename(), _dbName, config);

		java.util.Iterator p = _indices.iterator();
		while(p.hasNext())
		{
		    Index index = (Index) p.next();
		    index.associate(this, txn, createDb, populateEmptyIndices);
		}
		
		if(catalogData == null)
		{
		    catalogData = new CatalogData();
		    catalogData.evictor = true;
		    catalog.put(evictor.filename(), catalogData);
		}

		tx.commit();
	    }
	    catch(java.io.FileNotFoundException dx)
	    {
		NotFoundException ex = new NotFoundException();
		ex.initCause(dx);
		ex.message = _evictor.errorPrefix() + "Db.open: " + dx.getMessage();
		throw ex;
	    }
	    catch(com.sleepycat.db.DatabaseException dx)
	    {
		DatabaseException ex = new DatabaseException();
		ex.initCause(dx);
		ex.message = _evictor.errorPrefix() + "Db.open: " + dx.getMessage();
		throw ex;
	    }
	    finally
	    {
		Transaction tx = connection.currentTransaction();
		if(tx != null)
		{
		    try
		    {
			tx.rollback();
		    }
		    catch(DatabaseException de)
		    {
		    }
		}
	    }
	}
	finally
	{
	    connection.close();
	}
    }

    protected void
    finalize()
    {
        if(_db != null)
        {
            close();
        }
    }

    void
    close()
    {
	try
	{
	    _db.close();
	   
	    java.util.Iterator p = _indices.iterator();
	    while(p.hasNext())
	    {
		Index index = (Index) p.next();
		index.close();
	    }
	    _indices.clear();
	}
	catch(com.sleepycat.db.DatabaseException dx)
	{
	    DatabaseException ex = new DatabaseException();
	    ex.initCause(dx);
	    ex.message = _evictor.errorPrefix() + "Db.close: " + dx.getMessage();
	    throw ex;
	}
	_db = null;
    }
    
    boolean
    dbHasObject(Ice.Identity ident)
    {
	byte[] key = marshalKey(ident, _communicator);
	com.sleepycat.db.DatabaseEntry dbKey = new com.sleepycat.db.DatabaseEntry(key);
		
	//
	// Keep 0 length since we're not interested in the data
	//
	com.sleepycat.db.DatabaseEntry dbValue = new com.sleepycat.db.DatabaseEntry();
	dbValue.setPartial(true);
	
	for(;;)
	{
	    try
	    {	
		com.sleepycat.db.OperationStatus err = _db.get(null, dbKey, dbValue, null);
		
		if(err == com.sleepycat.db.OperationStatus.SUCCESS)
		{
		    return true;
		}
		else if(err == com.sleepycat.db.OperationStatus.NOTFOUND)
		{
		    return false;
		}
		else
		{
		    throw new DatabaseException();
		}
	    }
	    catch(com.sleepycat.db.DeadlockException dx)
	    {
		if(_evictor.deadlockWarning())
		{
		    _communicator.getLogger().warning("Deadlock in Freeze.ObjectStore.dhHasObject while reading " +
						      "Db \"" + _evictor.filename() + "/" + _dbName +
						      "\"; retrying...");
		}

		//
		// Ignored, try again
		//
	    }
	    catch(com.sleepycat.db.DatabaseException dx)
	    {
		DatabaseException ex = new DatabaseException();
		ex.initCause(dx);
		ex.message = _evictor.errorPrefix() + "Db.get: " + dx.getMessage();
		throw ex;
	    }
	}
    }

    void
    save(byte[] key, byte[] value, byte status, com.sleepycat.db.Transaction tx)
	throws com.sleepycat.db.DatabaseException
    {
	switch(status)
	{
	    case EvictorElement.created:
	    case EvictorElement.modified:
	    {
		com.sleepycat.db.DatabaseEntry dbKey = new com.sleepycat.db.DatabaseEntry(key);
		com.sleepycat.db.DatabaseEntry dbValue = new com.sleepycat.db.DatabaseEntry(value);
		com.sleepycat.db.OperationStatus err;
		if(status == EvictorElement.created)
		{
		    err = _db.putNoOverwrite(tx, dbKey, dbValue);
		}
		else
		{
		    err = _db.put(tx, dbKey, dbValue);
		}
		if(err != com.sleepycat.db.OperationStatus.SUCCESS)
		{
		    throw new DatabaseException();
		}
		break;
	    }
	    case EvictorElement.destroyed:
	    {
		com.sleepycat.db.DatabaseEntry dbKey = new com.sleepycat.db.DatabaseEntry(key);
		com.sleepycat.db.OperationStatus err = _db.delete(tx, dbKey);
		if(err != com.sleepycat.db.OperationStatus.SUCCESS)
		{
		    throw new DatabaseException();
		}
		break;
	    }
	    default:
	    {
		assert false;
	    }
	}
    }

    static byte[]
    marshalKey(Ice.Identity v, Ice.Communicator communicator)
    {
        IceInternal.BasicStream os = new IceInternal.BasicStream(Ice.Util.getInstance(communicator));
	v.__write(os);
	java.nio.ByteBuffer buf = os.prepareWrite();
	byte[] r = new byte[buf.limit()];
	buf.get(r);
	return r;
    }

    static Ice.Identity
    unmarshalKey(byte[] b, Ice.Communicator communicator)
    {
        IceInternal.BasicStream is = new IceInternal.BasicStream(Ice.Util.getInstance(communicator));
	is.resize(b.length, true);
	java.nio.ByteBuffer buf = is.prepareRead();
	buf.position(0);
	buf.put(b);
	buf.position(0);
	Ice.Identity key = new Ice.Identity();
	key.__read(is);
	return key;
    }

    static byte[]
    marshalValue(ObjectRecord v, Ice.Communicator communicator)
    {
        IceInternal.BasicStream os = new IceInternal.BasicStream(Ice.Util.getInstance(communicator));
	os.startWriteEncaps();
	v.__write(os);
	os.writePendingObjects();
	os.endWriteEncaps();
	java.nio.ByteBuffer buf = os.prepareWrite();
	byte[] r = new byte[buf.limit()];
	buf.get(r);
	return r;
    }

    static ObjectRecord
    unmarshalValue(byte[] b, Ice.Communicator communicator)
    {
        IceInternal.BasicStream is = new IceInternal.BasicStream(Ice.Util.getInstance(communicator));
        is.sliceObjects(false);
	is.resize(b.length, true);
	java.nio.ByteBuffer buf = is.prepareRead();
	buf.position(0);
	buf.put(b);
	buf.position(0);
	ObjectRecord rec= new ObjectRecord();
	is.startReadEncaps();
	rec.__read(is);
	is.readPendingObjects();
	is.endReadEncaps();
	return rec;
    }


    final IceUtil.Cache
    cache()
    {
	return _cache;
    }

    final com.sleepycat.db.Database
    db()
    {
	return _db;
    }
    
    final Ice.Communicator
    communicator()
    {
	return _communicator;
    }
    
    final EvictorI
    evictor()
    {
	return _evictor;
    }
    
    final String
    facet()
    {
	return _facet;
    }

    final String
    dbName()
    {
	return _dbName;
    }

    public Object
    load(Object identObj)
    {
	Ice.Identity ident = (Ice.Identity) identObj;

	byte[] key = marshalKey(ident, _communicator);

	com.sleepycat.db.DatabaseEntry dbKey = new com.sleepycat.db.DatabaseEntry(key);
	com.sleepycat.db.DatabaseEntry dbValue = new com.sleepycat.db.DatabaseEntry();

	for(;;)
	{
	    try
	    {	
		com.sleepycat.db.OperationStatus rs = _db.get(null, dbKey, dbValue, null);
		
		if(rs == com.sleepycat.db.OperationStatus.NOTFOUND)
		{
		    return null;
		}
		else if (rs != com.sleepycat.db.OperationStatus.SUCCESS)
		{
		    assert false;
		    throw new DatabaseException();
		}
		break;
	    }
	    catch(com.sleepycat.db.DeadlockException dx)
	    {
		if(_evictor.deadlockWarning())
		{
		    _communicator.getLogger().warning("Deadlock in Freeze.ObjectStore.load while reading Db \"" +
						      _evictor.filename() + "/" + _dbName + "\"; retrying...");
		}

		//
		// Ignored, try again
		//
	    }
	    catch(com.sleepycat.db.DatabaseException dx)
	    {
		DatabaseException ex = new DatabaseException();
		ex.initCause(dx);
		ex.message = _evictor.errorPrefix() + "Db.get: " + dx.getMessage();
		throw ex;
	    }
	}
	
	EvictorElement result = new EvictorElement(ident, this);
	result.rec = unmarshalValue(dbValue.getData(), _communicator);
	
	_evictor.initialize(ident, _facet, result.rec.servant);
	return result;
    }

    private final IceUtil.Cache _cache;
    
    private com.sleepycat.db.Database _db;
    private final String _facet;
    private final String _dbName;
    private final EvictorI _evictor;
    private final java.util.List _indices;
    private final Ice.Communicator _communicator;
}