private boolean createPartitionedIndex(Formatter f) throws IOException {
long start = System.currentTimeMillis();
// create partitions based on TimePartitionCollections object
for (CollectionManager dcm : tpc.makePartitions()) {
tp.addPartition(dcm);
}
List<TimePartition.Partition> bad = new ArrayList<TimePartition.Partition>();
for (TimePartition.Partition dc : tp.getPartitions()) {
try {
dc.makeGribCollection(f); // ensure collection has been read successfully
if (trace) f.format(" Open partition %s%n", dc.getDcm().getCollectionName());
} catch (Throwable t) {
logger.error(" Failed to open partition " + dc.getName(), t);
f.format(" FAIL on partition %s (remove) %n", dc.getDcm().getCollectionName());
bad.add(dc); // LOOK may be a file leak ?
}
}
// remove ones that failed
for (TimePartition.Partition p : bad) tp.removePartition(p);
// choose the "canonical" partition, aka prototype
int n = tp.getPartitions().size();
if (n == 0) {
logger.error(" Nothing in this partition = " + tp.getName());
f.format(" FAIL Partition empty collection = %s%n", tp.getName());
return false;
}
int idx = tpc.getProtoIndex(n);
TimePartition.Partition canon = tp.getPartitions().get(idx);
f.format(" Using canonical partition %s%n", canon.getDcm().getCollectionName());
// check consistency across vert and ens coords
if (!checkPartitions(canon, f)) {
logger.error(
" Partition check failed, index not written on {} message = {}",
tp.getName(),
f.toString());
f.format(" FAIL Partition check collection = %s%n", tp.getName());
return false;
}
// make the time coordinates, place results into canon
createPartitionedTimeCoordinates(canon, f);
// ready to write the index file
writeIndex(canon, f);
// close open gc's
tp.cleanup();
long took = System.currentTimeMillis() - start;
f.format(" CreatePartitionedIndex took %d msecs%n", took);
return true;
}
/*
MAGIC_START
version
sizeRecords
VariableRecords (sizeRecords bytes)
sizeIndex
GribCollectionIndex (sizeIndex bytes)
*/
private boolean writeIndex(TimePartition.Partition canon, Formatter f) throws IOException {
File file = tp.getIndexFile();
if (file.exists()) {
if (!file.delete()) logger.error("Cant delete " + file.getPath());
}
RandomAccessFile raf = new RandomAccessFile(file.getPath(), "rw");
raf.order(RandomAccessFile.BIG_ENDIAN);
try {
//// header message
raf.write(MAGIC_START.getBytes("UTF-8"));
raf.writeInt(version);
raf.writeLong(0); // no record section
GribCollectionProto.GribCollectionIndex.Builder indexBuilder =
GribCollectionProto.GribCollectionIndex.newBuilder();
indexBuilder.setName(tp.getName());
GribCollection canonGc = canon.makeGribCollection(f);
for (GribCollection.GroupHcs g : canonGc.getGroups())
indexBuilder.addGroups(writeGroupProto(g));
indexBuilder.setCenter(canonGc.getCenter());
indexBuilder.setSubcenter(canonGc.getSubcenter());
indexBuilder.setMaster(canonGc.getMaster());
indexBuilder.setLocal(canonGc.getLocal());
for (TimePartition.Partition p : tp.getPartitions()) {
indexBuilder.addPartitions(writePartitionProto(p.getName(), (TimePartition.Partition) p));
}
GribCollectionProto.GribCollectionIndex index = indexBuilder.build();
byte[] b = index.toByteArray();
NcStream.writeVInt(raf, b.length); // message size
raf.write(b); // message - all in one gulp
f.format("GribCollectionTimePartitionedIndex= %d bytes%n", b.length);
} finally {
f.format("file size = %d bytes%n", raf.length());
raf.close();
}
return true;
}
private boolean createPartitionedTimeCoordinates(TimePartition.Partition canon, Formatter f)
throws IOException {
List<TimePartition.Partition> partitions = tp.getPartitions();
boolean ok = true;
// for each group in canonical Partition
for (GribCollection.GroupHcs firstGroup : canon.makeGribCollection(f).getGroups()) {
String gname = firstGroup.getId();
if (trace) f.format(" Check Group %s%n", gname);
// get list of corresponding groups from all the time partition, so we dont have to keep
// looking it up
List<PartGroup> pgList = new ArrayList<PartGroup>(partitions.size());
for (TimePartition.Partition dc : partitions) {
GribCollection.GroupHcs gg = dc.makeGribCollection(f).findGroupById(gname);
if (gg == null) logger.error(" Cant find group {} in partition {}", gname, dc.getName());
else pgList.add(new PartGroup(gg, dc));
}
// unique time coordinate unions
List<TimeCoordUnion> unionList = new ArrayList<TimeCoordUnion>();
// for each variable in canonical Partition
for (GribCollection.VariableIndex viCanon : firstGroup.varIndex) {
if (trace) f.format(" Check variable %s%n", viCanon);
TimeCoord tcCanon = viCanon.getTimeCoord();
List<TimeCoord> tcPartitions = new ArrayList<TimeCoord>(pgList.size());
// for each partition, get the time index
for (PartGroup pg : pgList) {
// get corresponding variable
GribCollection.VariableIndex vi2 = pg.group.findVariableByHash(viCanon.cdmHash);
if (vi2 == null) { // apparently not in the file
f.format(
" WARN Cant find variable %s in partition %s / %s%n",
viCanon, pg.tpp.getName(), pg.group.getId());
tcPartitions.add(null);
} else {
if (vi2.timeIdx < 0 || vi2.timeIdx >= pg.group.timeCoords.size()) {
logger.error(" timeIdx out of range var= {} on partition {}", vi2, pg.tpp.getName());
tcPartitions.add(null);
} else {
TimeCoord tc2 = vi2.getTimeCoord();
if (tc2.isInterval() != tcCanon.isInterval()) {
logger.error(
" timeIdx wrong interval type var= {} on partition {}", vi2, pg.tpp.getName());
tcPartitions.add(null);
} else {
tcPartitions.add(tc2);
}
}
}
}
// union of time coordinates
TimeCoordUnion union = new TimeCoordUnion(tcCanon.getCode(), tcPartitions, tcCanon);
// store result in the first group
viCanon.partTimeCoordIdx =
TimeCoordUnion.findUnique(unionList, union); // this merges identical TimeCoordUnion
}
/* turn TimeIndex into TimeCoord
for (int tidx = 0; tidx <unionList.size(); tidx++) {
TimeCoordUnion union = unionList.get(tidx);
f.format(" %s %d: timeIndexList=", firstGroup.hcs.getName(), tidx);
for (int idx : union.) f.format("%d,",idx);
f.format("%n");
} */
// store results in first group
firstGroup.timeCoordPartitions = unionList;
}
return ok;
}
private void createIndex(
File indexFile, List<Group> groups, ArrayList<String> filenames, Formatter f)
throws IOException {
Grib2Record first = null; // take global metadata from here
if (indexFile.exists()) indexFile.delete(); // replace it
f.format(" createIndex for %s%n", indexFile.getPath());
RandomAccessFile raf = new RandomAccessFile(indexFile.getPath(), "rw");
raf.order(RandomAccessFile.BIG_ENDIAN);
try {
//// header message
raf.write(MAGIC_START.getBytes("UTF-8"));
raf.writeInt(version);
long lenPos = raf.getFilePointer();
raf.writeLong(0); // save space to write the length of the record section
long countBytes = 0;
int countRecords = 0;
for (Group g : groups) {
g.fileSet = new HashSet<Integer>();
for (Grib2Rectilyser.VariableBag vb : g.rect.getGribvars()) {
if (first == null) first = vb.first;
GribCollectionProto.VariableRecords vr = writeRecordsProto(vb, g.fileSet);
byte[] b = vr.toByteArray();
vb.pos = raf.getFilePointer();
vb.length = b.length;
raf.write(b);
countBytes += b.length;
countRecords += vb.recordMap.length;
}
}
long bytesPerRecord = countBytes / ((countRecords == 0) ? 1 : countRecords);
f.format(
" write RecordMaps: bytes = %d record = %d bytesPerRecord=%d%n",
countBytes, countRecords, bytesPerRecord);
if (first == null) {
logger.error("GribCollection {}: has no files\n{}", gc.getName(), f.toString());
throw new IllegalArgumentException("GribCollection " + gc.getName() + " has no files");
}
long pos = raf.getFilePointer();
raf.seek(lenPos);
raf.writeLong(countBytes);
raf.seek(pos); // back to the output.
GribCollectionProto.GribCollectionIndex.Builder indexBuilder =
GribCollectionProto.GribCollectionIndex.newBuilder();
indexBuilder.setName(gc.getName());
for (String fn : filenames) indexBuilder.addFiles(fn);
for (Group g : groups) indexBuilder.addGroups(writeGroupProto(g));
/* int count = 0;
for (DatasetCollectionManager dcm : collections) {
indexBuilder.addParams(makeParamProto(new Parameter("spec" + count, dcm.())));
count++;
} */
// what about just storing first ??
Grib2SectionIdentification ids = first.getId();
indexBuilder.setCenter(ids.getCenter_id());
indexBuilder.setSubcenter(ids.getSubcenter_id());
indexBuilder.setMaster(ids.getMaster_table_version());
indexBuilder.setLocal(ids.getLocal_table_version());
Grib2Pds pds = first.getPDS();
indexBuilder.setGenProcessType(pds.getGenProcessType());
indexBuilder.setGenProcessId(pds.getGenProcessId());
indexBuilder.setBackProcessId(pds.getBackProcessId());
GribCollectionProto.GribCollectionIndex index = indexBuilder.build();
byte[] b = index.toByteArray();
NcStream.writeVInt(raf, b.length); // message size
raf.write(b); // message - all in one gulp
f.format(" write GribCollectionIndex= %d bytes%n", b.length);
} finally {
f.format(" file size = %d bytes%n", raf.length());
raf.close();
if (raf != null) raf.close();
}
}
public boolean readIndex(RandomAccessFile raf) {
gc.setRaf(raf); // LOOK leaving the raf open in the GribCollection
try {
raf.order(RandomAccessFile.BIG_ENDIAN);
raf.seek(0);
//// header message
if (!NcStream.readAndTest(raf, MAGIC_START.getBytes())) {
logger.error("GribCollection {}: invalid index", gc.getName());
return false;
}
int v = raf.readInt();
if (v != getVersion()) {
logger.warn(
"GribCollection {}: index found version={}, want version= {} on file {}",
new Object[] {gc.getName(), v, version, raf.getLocation()});
return false;
}
long skip = raf.readLong();
raf.skipBytes(skip);
int size = NcStream.readVInt(raf);
if ((size < 0) || (size > 100 * 1000 * 1000)) {
logger.warn("GribCollection {}: invalid index ", gc.getName());
return false;
}
byte[] m = new byte[size];
raf.readFully(m);
GribCollectionProto.GribCollectionIndex proto =
GribCollectionProto.GribCollectionIndex.parseFrom(m);
gc.center = proto.getCenter();
gc.subcenter = proto.getSubcenter();
gc.master = proto.getMaster();
gc.local = proto.getLocal();
gc.genProcessType = proto.getGenProcessType();
gc.genProcessId = proto.getGenProcessId();
gc.backProcessId = proto.getBackProcessId();
gc.local = proto.getLocal();
// gc.tables = Grib2Tables.factory(gc.center, gc.subcenter, gc.master, gc.local);
gc.filenames = new ArrayList<String>(proto.getFilesCount());
for (int i = 0; i < proto.getFilesCount(); i++) gc.filenames.add(proto.getFiles(i));
// error condition on a GribCollection Index
if ((proto.getFilesCount() == 0) && !(this instanceof TimePartitionBuilder)) {
logger.warn("GribCollection {}: has no files, force recreate ", gc.getName());
return false;
}
gc.groups = new ArrayList<GribCollection.GroupHcs>(proto.getGroupsCount());
for (int i = 0; i < proto.getGroupsCount(); i++)
gc.groups.add(readGroup(proto.getGroups(i), gc.makeGroup()));
Collections.sort(gc.groups);
gc.params = new ArrayList<Parameter>(proto.getParamsCount());
for (int i = 0; i < proto.getParamsCount(); i++) gc.params.add(readParam(proto.getParams(i)));
if (!readPartitions(proto)) {
logger.warn("TimePartition {}: has no partitions, force recreate ", gc.getName());
return false;
}
return true;
} catch (Throwable t) {
logger.error("Error reading index " + raf.getLocation(), t);
return false;
}
}