private void updateFullDatabaseVersionCache() { fullDatabaseVersionCache = new DatabaseVersion(); for (DatabaseVersion databaseVersion : databaseVersions) { updateFullDatabaseVersionCache(databaseVersion); } }
private PartialFileHistory createNewFileHistory(PartialFileHistory lastFileHistory) { if (lastFileHistory == null) { FileHistoryId newFileHistoryId = FileHistoryId.secureRandomFileId(); return new PartialFileHistory(newFileHistoryId); } else { return new PartialFileHistory(lastFileHistory.getFileHistoryId()); } }
public static FileHistoryId parseFileId(String s) { return new FileHistoryId(ObjectId.parseObjectId(s)); } }
public static DatabaseVersion createDatabaseVersion(DatabaseVersionHeader basedOnDatabaseVersionHeader, Date date) { VectorClock vectorClock = (basedOnDatabaseVersionHeader != null) ? basedOnDatabaseVersionHeader.getVectorClock().clone() : new VectorClock(); vectorClock.incrementClock("someclient"); DatabaseVersion databaseVersion = new DatabaseVersion(); databaseVersion.setClient("someclient"); databaseVersion.setTimestamp(date); databaseVersion.setVectorClock(vectorClock); return databaseVersion; } }
private PartialFileHistory getFileHistoryByPathFromDatabaseVersion(DatabaseVersion databaseVersion, String path) { // TODO [medium] Extremely performance intensive, because this is called inside a loop above. Implement better caching for database version!!! for (PartialFileHistory fileHistory : databaseVersion.getFileHistories()) { FileVersion lastVersion = fileHistory.getLastVersion(); if (lastVersion.getStatus() != FileStatus.DELETED && lastVersion.getPath().equals(path)) { return fileHistory; } } return null; }
public static MultiChunkId parseMultiChunkId(String s) { return new MultiChunkId(ObjectId.parseObjectId(s)); } }
public static ChunkChecksum parseChunkChecksum(String s) { return new ChunkChecksum(ObjectId.parseObjectId(s)); } }
public static FileChecksum parseFileChecksum(String s) { return new FileChecksum(ObjectId.parseObjectId(s)); }
/** * Persists a regular database version to the local database by using * {@link SqlDatabase#writeDatabaseVersion(DatabaseVersion)}. */ private void persistDatabaseVersion(MemoryDatabase winnersDatabase, DatabaseVersionHeader currentDatabaseVersionHeader) { logger.log(Level.INFO, " + Applying database version " + currentDatabaseVersionHeader.getVectorClock()); DatabaseVersion applyDatabaseVersion = winnersDatabase.getDatabaseVersion(currentDatabaseVersionHeader.getVectorClock()); logger.log(Level.FINE, " + Contents: " + applyDatabaseVersion); localDatabase.writeDatabaseVersion(applyDatabaseVersion); }
public static MultiChunkId secureRandomMultiChunkId() { return new MultiChunkId(ObjectId.secureRandomBytes(MULTICHUNK_ID_LENGTH)); }
public static FileHistoryId secureRandomFileId() { return new FileHistoryId(ObjectId.secureRandomBytes(FILE_HISTORY_ID_LENGTH)); }
/** * Retrieve the unit's value * * @param unit The identifier of the vector element being retrieved * @return Returns the value of the unit (if existent), or <tt>null</tt> if it does not exist */ public Long getClock(String unit) { return get(unit); }
public LsOperation(Config config, LsOperationOptions options) { super(config); this.options = options; this.localDatabase = new SqlDatabase(config); }
/** * Get a multichunk that this chunk is contained in. */ public MultiChunkId getMultiChunkIdForChunk(ChunkChecksum chunk) { return fullDatabaseVersionCache.getMultiChunkId(chunk); }
@Override public int hashCode() { final int prime = 31; int result = 1; result = prime * result + ((id == null) ? 0 : id.hashCode()); result = prime * result + minSize; result = prime * result + (int) (size ^ (size >>> 32)); return result; }
@Override public String apply(FileHistoryId fileHistoryId) { return fileHistoryId.toString(); } }).toArray(new String[0]);
@Override public int hashCode() { final int prime = 31; int result = 1; result = prime * result + ((header == null) ? 0 : header.hashCode()); return result; }
@Override public int hashCode() { final int prime = 31; int result = 1; result = prime * result + ((checksum == null) ? 0 : checksum.hashCode()); result = prime * result + size; return result; }
public static boolean fileChecksumEquals(FileChecksum checksum1, FileChecksum checksum2) { if (checksum1 != null && checksum2 != null) { return checksum1.equals(checksum2); } else { return checksum1 == null && checksum2 == null; } } }
private void updateFilenameHistoryCache() { // TODO [medium] Performance: This throws away the unchanged entries. It should only update new database version filenameHistoryCache.clear(); for (PartialFileHistory cacheFileHistory : fullDatabaseVersionCache.getFileHistories()) { FileVersion lastVersion = cacheFileHistory.getLastVersion(); String fileName = lastVersion.getPath(); if (lastVersion.getStatus() != FileStatus.DELETED) { filenameHistoryCache.put(fileName, cacheFileHistory); } } }