/*
* Copyright (C) 2010, Constantine Plotnikov <constantine.plotnikov@gmail.com>
* Copyright (C) 2010, JetBrains s.r.o.
* and other copyright owners as documented in the project's IP log.
*
* This program and the accompanying materials are made available
* under the terms of the Eclipse Distribution License v1.0 which
* accompanies this distribution, is reproduced below, and is
* available at http://www.eclipse.org/org/documents/edl-v10.php
*
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or
* without modification, are permitted provided that the following
* conditions are met:
*
* - Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* - Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided
* with the distribution.
*
* - Neither the name of the Eclipse Foundation, Inc. nor the
* names of its contributors may be used to endorse or promote
* products derived from this software without specific prior
* written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
* CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package org.eclipse.jgit.internal.storage.file;
import java.io.File;
import java.io.IOException;
import java.util.Collection;
import java.util.Set;
import org.eclipse.jgit.internal.storage.pack.ObjectToPack;
import org.eclipse.jgit.internal.storage.pack.PackWriter;
import org.eclipse.jgit.lib.AbbreviatedObjectId;
import org.eclipse.jgit.lib.AnyObjectId;
import org.eclipse.jgit.lib.Config;
import org.eclipse.jgit.lib.Constants;
import org.eclipse.jgit.lib.ObjectDatabase;
import org.eclipse.jgit.lib.ObjectId;
import org.eclipse.jgit.lib.ObjectIdOwnerMap;
import org.eclipse.jgit.lib.ObjectLoader;
import org.eclipse.jgit.util.FS;
/**
* The cached instance of an {@link ObjectDirectory}.
* <p>
* This class caches the list of loose objects in memory, so the file system is
* not queried with stat calls.
*/
class CachedObjectDirectory extends FileObjectDatabase {
/**
* The set that contains unpacked objects identifiers, it is created when
* the cached instance is created.
*/
private ObjectIdOwnerMap<UnpackedObjectId> unpackedObjects;
private final ObjectDirectory wrapped;
private CachedObjectDirectory[] alts;
/**
* The constructor
*
* @param wrapped
* the wrapped database
*/
CachedObjectDirectory(ObjectDirectory wrapped) {
this.wrapped = wrapped;
this.unpackedObjects = scanLoose();
}
private ObjectIdOwnerMap<UnpackedObjectId> scanLoose() {
ObjectIdOwnerMap<UnpackedObjectId> m = new ObjectIdOwnerMap<UnpackedObjectId>();
File objects = wrapped.getDirectory();
String[] fanout = objects.list();
if (fanout == null)
return m;
for (String d : fanout) {
if (d.length() != 2)
continue;
String[] entries = new File(objects, d).list();
if (entries == null)
continue;
for (String e : entries) {
if (e.length() != Constants.OBJECT_ID_STRING_LENGTH - 2)
continue;
try {
ObjectId id = ObjectId.fromString(d + e);
m.add(new UnpackedObjectId(id));
} catch (IllegalArgumentException notAnObject) {
// ignoring the file that does not represent loose object
}
}
}
return m;
}
@Override
public void close() {
// Don't close anything.
}
@Override
public ObjectDatabase newCachedDatabase() {
return this;
}
@Override
File getDirectory() {
return wrapped.getDirectory();
}
@Override
File fileFor(AnyObjectId id) {
return wrapped.fileFor(id);
}
@Override
Config getConfig() {
return wrapped.getConfig();
}
@Override
FS getFS() {
return wrapped.getFS();
}
@Override
Set<ObjectId> getShallowCommits() throws IOException {
return wrapped.getShallowCommits();
}
private CachedObjectDirectory[] myAlternates() {
if (alts == null) {
ObjectDirectory.AlternateHandle[] src = wrapped.myAlternates();
alts = new CachedObjectDirectory[src.length];
for (int i = 0; i < alts.length; i++)
alts[i] = src[i].db.newCachedFileObjectDatabase();
}
return alts;
}
@Override
void resolve(Set<ObjectId> matches, AbbreviatedObjectId id)
throws IOException {
// In theory we could accelerate the loose object scan using our
// unpackedObjects map, but its not worth the huge code complexity.
// Scanning a single loose directory is fast enough, and this is
// unlikely to be called anyway.
//
wrapped.resolve(matches, id);
}
@Override
public boolean has(final AnyObjectId objectId) throws IOException {
if (unpackedObjects.contains(objectId))
return true;
if (wrapped.hasPackedObject(objectId))
return true;
for (CachedObjectDirectory alt : myAlternates()) {
if (alt.has(objectId))
return true;
}
return false;
}
@Override
ObjectLoader openObject(final WindowCursor curs,
final AnyObjectId objectId) throws IOException {
ObjectLoader ldr = openLooseObject(curs, objectId);
if (ldr != null)
return ldr;
ldr = wrapped.openPackedObject(curs, objectId);
if (ldr != null)
return ldr;
for (CachedObjectDirectory alt : myAlternates()) {
ldr = alt.openObject(curs, objectId);
if (ldr != null)
return ldr;
}
return null;
}
@Override
long getObjectSize(WindowCursor curs, AnyObjectId objectId)
throws IOException {
// Object size is unlikely to be requested from contexts using
// this type. Don't bother trying to accelerate the lookup.
return wrapped.getObjectSize(curs, objectId);
}
@Override
ObjectLoader openLooseObject(WindowCursor curs, AnyObjectId id)
throws IOException {
if (unpackedObjects.contains(id)) {
ObjectLoader ldr = wrapped.openLooseObject(curs, id);
if (ldr != null)
return ldr;
unpackedObjects = scanLoose();
}
return null;
}
@Override
InsertLooseObjectResult insertUnpackedObject(File tmp, ObjectId objectId,
boolean createDuplicate) throws IOException {
InsertLooseObjectResult result = wrapped.insertUnpackedObject(tmp,
objectId, createDuplicate);
switch (result) {
case INSERTED:
case EXISTS_LOOSE:
unpackedObjects.addIfAbsent(new UnpackedObjectId(objectId));
break;
case EXISTS_PACKED:
case FAILURE:
break;
}
return result;
}
@Override
PackFile openPack(File pack) throws IOException {
return wrapped.openPack(pack);
}
@Override
void selectObjectRepresentation(PackWriter packer, ObjectToPack otp,
WindowCursor curs) throws IOException {
wrapped.selectObjectRepresentation(packer, otp, curs);
}
@Override
Collection<PackFile> getPacks() {
return wrapped.getPacks();
}
private static class UnpackedObjectId extends ObjectIdOwnerMap.Entry {
UnpackedObjectId(AnyObjectId id) {
super(id);
}
}
}