else if (index.getRevision() != revision) if (revision < index.getRevision()) logger.warn("Index {} revision is going BACKWARDS! (our revision {}, their revision {})", index.getId(), index.getRevision(), revision); logger.info("Index {} has the wrong revision (our revision {}, their revision {})", index.getId(), index.getRevision(), revision); else if (index.getCrc() != crc) index.getCrc(), index.getCrc(), crc); logger.info("Index {} is up to date", index.getId()); index.setProtocol(indexData.getProtocol()); index.setNamed(indexData.isNamed()); index.setCrc(crc); index.setRevision(revision); Archive existing = index.getArchive(ad.getId()); ad.getId(), indexData.getArchives().length, index.getId()); continue; ad.getId(), indexData.getArchives().length, index.getId()); ad.getId(), indexData.getArchives().length, index.getId(), existing.getRevision(), ad.getRevision());
for (Index idx : store.getIndexes()) String file = idx.getId() + EXTENSION; try (PrintStream br = new PrintStream(openWriter(file))) br.printf("protocol=%d\n", idx.getProtocol()); br.printf("revision=%d\n", idx.getRevision()); br.printf("compression=%d\n", idx.getCompression()); br.printf("crc=%d\n", idx.getCrc()); br.printf("named=%b\n", idx.getCompression()); idx.getArchives().sort(Comparator.comparing(Archive::getArchiveId)); for (Archive archive : idx.getArchives())
private void saveIndex(Index index) throws IOException { IndexData indexData = index.toIndexData(); byte[] data = indexData.writeIndexData(); Container container = new Container(index.getCompression(), -1); // index data revision is always -1 container.compress(data, null); byte[] compressedData = container.data; DataFileWriteResult res = this.data.write(index255.getIndexFileId(), index.getId(), compressedData); index255.write(new IndexEntry(index255, index.getId(), res.sector, res.compressedLength)); Crc32 crc = new Crc32(); crc.update(compressedData, 0, compressedData.length); index.setCrc(crc.getHash()); }
private void loadIndex(Index index) throws IOException { logger.trace("Loading index {}", index.getId()); byte[] indexData = readIndex(index.getId()); Container res = Container.decompress(indexData, null); byte[] data = res.data; IndexData id = new IndexData(); id.load(data); index.setProtocol(id.getProtocol()); index.setRevision(id.getRevision()); index.setNamed(id.isNamed()); for (ArchiveData ad : id.getArchives()) { Archive archive = index.addArchive(ad.getId()); archive.setNameHash(ad.getNameHash()); archive.setCrc(ad.getCrc()); archive.setRevision(ad.getRevision()); archive.setFileData(ad.getFiles()); assert ad.getFiles().length > 0; } index.setCrc(res.crc); index.setCompression(res.compression); assert res.revision == -1; }
public void load() throws IOException { Storage storage = store.getStorage(); Index index = store.getIndex(IndexType.TEXTURES); Archive archive = index.getArchive(0); byte[] archiveData = storage.loadArchive(archive); ArchiveFiles files = archive.getFiles(archiveData); TextureLoader loader = new TextureLoader(); for (FSFile file : files.getFiles()) { TextureDefinition texture = loader.load(file.getFileId(), file.getContents()); textures.add(texture); } }
@Override public void load(Store store) throws IOException { List<IndexEntry> indexes = cacheDao.findIndexesForCache(con, cacheEntry); for (IndexEntry indexEntry : indexes) { Index index = store.addIndex(indexEntry.getIndexId()); index.setCrc(indexEntry.getCrc()); index.setRevision(indexEntry.getRevision()); try (ResultSetIterable<ArchiveEntry> archives = cacheDao.findArchivesForIndex(con, indexEntry)) { for (ArchiveEntry archiveEntry : archives) { if (index.getArchive(archiveEntry.getArchiveId()) != null) { throw new IOException("Duplicate archive " + archiveEntry + " on " + indexEntry); } Archive archive = index.addArchive(archiveEntry.getArchiveId()); archive.setNameHash(archiveEntry.getNameHash()); archive.setCrc(archiveEntry.getCrc()); archive.setRevision(archiveEntry.getRevision()); archive.setHash(archiveEntry.getHash()); // File data is not necessary for cache updating } } } }
@Override public void save(Store store) throws IOException { for (Index index : store.getIndexes()) { IndexEntry entry = cacheDao.createIndex(con, cacheEntry, index.getId(), index.getCrc(), index.getRevision()); for (Archive archive : index.getArchives()) { ArchiveEntry archiveEntry = cacheDao.findArchive(con, entry, archive.getArchiveId(), archive.getNameHash(), archive.getCrc(), archive.getRevision()); if (archiveEntry == null) { byte[] hash = archive.getHash(); archiveEntry = cacheDao.createArchive(con, entry, archive.getArchiveId(), archive.getNameHash(), archive.getCrc(), archive.getRevision(), hash); for (FileData file : archive.getFileData()) { cacheDao.associateFileToArchive(con, archiveEntry, file.getId(), file.getNameHash()); } } cacheDao.associateArchiveToIndex(con, archiveEntry, entry); } } }
archive = index.addArchive(0); archive2 = index.addArchive(1); Archive archive2_1 = index.getArchive(0); Archive archive2_2 = index.getArchive(1);
public void load() throws IOException { InterfaceLoader loader = new InterfaceLoader(); Storage storage = store.getStorage(); Index index = store.getIndex(IndexType.INTERFACES); int max = index.getArchives().stream().mapToInt(a -> a.getArchiveId()).max().getAsInt(); interfaces = new InterfaceDefinition[max + 1][]; for (Archive archive : index.getArchives()) { int archiveId = archive.getArchiveId(); byte[] archiveData = storage.loadArchive(archive); ArchiveFiles files = archive.getFiles(archiveData); InterfaceDefinition[] ifaces = interfaces[archiveId]; if (ifaces == null) { ifaces = interfaces[archiveId] = new InterfaceDefinition[archive.getFileData().length]; } for (FSFile file : files.getFiles()) { int fileId = file.getFileId(); int widgetId = (archiveId << 16) + fileId; InterfaceDefinition iface = loader.load(widgetId, file.getContents()); ifaces[fileId] = iface; } } }
public Index findIndex(int id) { for (Index i : indexes) { if (i.getId() == id) { return i; } } return null; } }
Index index2 = store.addIndex(1); Archive archive = index.addArchive(0); archive.setNameHash(random.nextInt(Integer.MAX_VALUE)); archive.setFileData(new FileData[NUMBER_OF_FILES]); Archive archive2 = index.addArchive(1); archive2.setFileData(new FileData[NUMBER_OF_FILES]); Archive archive3 = index2.addArchive(0); archive3.setFileData(new FileData[NUMBER_OF_FILES]);
Archive map = index.findArchiveByName("m" + x + "_" + y); Archive land = index.findArchiveByName("l" + x + "_" + y);
String file = idx.getId() + EXTENSION; try (BufferedReader br = new BufferedReader(new InputStreamReader(openReader(file)))) archive = idx.addArchive(Integer.parseInt(value)); continue; idx.setProtocol(Integer.parseInt(value)); continue; case "revision": idx.setRevision(Integer.parseInt(value)); continue; case "compression": idx.setCompression(Integer.parseInt(value)); continue; case "crc": idx.setCrc(Integer.parseInt(value)); continue; case "named": idx.setNamed(Boolean.parseBoolean(value)); continue; continue; case "contents": data.put((long) idx.getId() << 32 | archive.getArchiveId(), Base64.getDecoder().decode(value)); continue;
public void load() throws IOException { Storage storage = store.getStorage(); Index index = store.getIndex(IndexType.CONFIGS); Archive archive = index.getArchive(ConfigType.AREA.getId()); byte[] archiveData = storage.loadArchive(archive); ArchiveFiles files = archive.getFiles(archiveData); for (FSFile file : files.getFiles()) { AreaLoader loader = new AreaLoader(); AreaDefinition area = loader.load(file.getContents(), file.getFileId()); areas.put(area.id, area); } }
archive = index.addArchive(0); archive2 = index.addArchive(1); Archive archive2_1 = index.getArchive(0); Archive archive2_2 = index.getArchive(1);
public void load() throws IOException { Storage storage = store.getStorage(); Index index = store.getIndex(IndexType.SPRITES); for (Archive a : index.getArchives()) { byte[] contents = a.decompress(storage.loadArchive(a)); SpriteLoader loader = new SpriteLoader(); SpriteDefinition[] defs = loader.load(a.getArchiveId(), contents); for (SpriteDefinition sprite : defs) { sprites.put(sprite.getId(), sprite); } } }
@Override public void saveArchive(Archive archive, byte[] bytes) throws IOException { data.put((long) archive.getIndex().getId() << 32 | archive.getArchiveId(), bytes); } }
@Test public void testManyFiles() throws IOException { Random random = new Random(42L); File root = folder.newFolder(); try (Store store = new Store(root)) { Index index = store.addIndex(0); Archive archive = index.addArchive(0); archive.setNameHash(random.nextInt()); archive.setFileData(new FileData[NUMBER_OF_FILES]); for (int i = 0; i < NUMBER_OF_FILES; ++i) { FileData[] fileData = archive.getFileData(); FileData file = fileData[i] = new FileData(); file.setId(i); file.setNameHash(random.nextInt()); } store.save(); try (Store store2 = new Store(root)) { store2.load(); Assert.assertEquals(store, store2); } } }
@Test public void extract() throws IOException { File base = StoreLocation.LOCATION, outFile = folder.newFolder(); try (Store store = new Store(base)) { store.load(); Storage storage = store.getStorage(); Index index = store.getIndex(IndexType.BINARY); Archive archive = index.findArchiveByName("title.jpg"); byte[] contents = archive.decompress(storage.loadArchive(archive)); Files.write(outFile.toPath(), contents); } logger.info("Dumped to {}", outFile); } }