func readEntries(handle IndexInputSlicer, dir Directory, name string) (mapping map[string]FileEntry, err error) {
var stream, entriesStream IndexInput = nil, nil
defer func() {
err = util.CloseWhileHandlingError(err, stream, entriesStream)
}()
// read the first VInt. If it is negative, it's the version number
// otherwise it's the count (pre-3.1 indexes)
mapping = make(map[string]FileEntry)
stream = handle.openFullSlice()
log.Printf("Reading from stream: %v", stream)
firstInt, err := stream.ReadVInt()
if err != nil {
return mapping, err
}
// impossible for 3.0 to have 63 files in a .cfs, CFS writer was not visible
// and separate norms/etc are outside of cfs.
if firstInt == int32(CODEC_MAGIC_BYTE1) {
if secondByte, err := stream.ReadByte(); err == nil {
if thirdByte, err := stream.ReadByte(); err == nil {
if fourthByte, err := stream.ReadByte(); err == nil {
if secondByte != CODEC_MAGIC_BYTE2 ||
thirdByte != CODEC_MAGIC_BYTE3 ||
fourthByte != CODEC_MAGIC_BYTE4 {
return mapping, errors.New(fmt.Sprintf(
"Illegal/impossible header for CFS file: %v,%v,%v",
secondByte, thirdByte, fourthByte))
}
}
}
}
if err != nil {
return mapping, err
}
_, err = codec.CheckHeaderNoMagic(stream, CFD_DATA_CODEC, CFD_VERSION_START, CFD_VERSION_START)
if err != nil {
return mapping, err
}
entriesFileName := util.SegmentFileName(util.StripExtension(name), "", COMPOUND_FILE_ENTRIES_EXTENSION)
entriesStream, err = dir.OpenInput(entriesFileName, IO_CONTEXT_READONCE)
if err != nil {
return mapping, err
}
_, err = codec.CheckHeader(entriesStream, CFD_ENTRY_CODEC, CFD_VERSION_START, CFD_VERSION_START)
if err != nil {
return mapping, err
}
numEntries, err := entriesStream.ReadVInt()
if err != nil {
return mapping, err
}
log.Printf("Entries number: %v", numEntries)
for i := int32(0); i < numEntries; i++ {
id, err := entriesStream.ReadString()
if err != nil {
return mapping, err
}
if _, ok := mapping[id]; ok {
return mapping, errors.New(fmt.Sprintf(
"Duplicate cfs entry id=%v in CFS: %v", id, entriesStream))
}
log.Printf("Found entry: %v", id)
offset, err := entriesStream.ReadLong()
if err != nil {
return mapping, err
}
length, err := entriesStream.ReadLong()
if err != nil {
return mapping, err
}
mapping[id] = FileEntry{offset, length}
}
} else {
// TODO remove once 3.x is not supported anymore
panic("not supported yet; will also be obsolete soon")
}
return mapping, nil
}
func (sis *SegmentInfos) Read(directory store.Directory, segmentFileName string) error {
log.Printf("Reading segment info from %v...", segmentFileName)
success := false
// Clear any previous segments:
sis.Clear()
sis.generation = GenerationFromSegmentsFileName(segmentFileName)
sis.lastGeneration = sis.generation
main, err := directory.OpenInput(segmentFileName, store.IO_CONTEXT_READ)
if err != nil {
return err
}
input := store.NewChecksumIndexInput(main)
defer func() {
if !success {
// Clear any segment infos we had loaded so we
// have a clean slate on retry:
sis.Clear()
util.CloseWhileSuppressingError(input)
} else {
input.Close()
}
}()
format, err := input.ReadInt()
if err != nil {
return err
}
if format == codec.CODEC_MAGIC {
// 4.0+
_, err = codec.CheckHeaderNoMagic(input, "segments", VERSION_40, VERSION_40)
if err != nil {
return err
}
sis.version, err = input.ReadLong()
if err != nil {
return err
}
sis.counter, err = asInt(input.ReadInt())
if err != nil {
return err
}
numSegments, err := asInt(input.ReadInt())
if err != nil {
return err
}
if numSegments < 0 {
return errors.New(fmt.Sprintf("invalid segment count: %v (resource: %v)", numSegments, input))
}
for seg := 0; seg < numSegments; seg++ {
segName, err := input.ReadString()
if err != nil {
return err
}
codecName, err := input.ReadString()
if err != nil {
return err
}
if codecName != "Lucene42" {
log.Panicf("Not supported yet: %v", codecName)
}
// method := CodecForName(codecName)
method := NewLucene42Codec()
info, err := method.ReadSegmentInfo(directory, segName, store.IO_CONTEXT_READ)
if err != nil {
return err
}
info.codec = method
delGen, err := input.ReadLong()
if err != nil {
return err
}
delCount, err := asInt(input.ReadInt())
if err != nil {
return err
}
if delCount < 0 || delCount > int(info.docCount) {
return errors.New(fmt.Sprintf("invalid deletion count: %v (resource: %v)", delCount, input))
}
sis.Segments = append(sis.Segments, NewSegmentInfoPerCommit(info, delCount, delGen))
}
sis.userData, err = input.ReadStringStringMap()
if err != nil {
return err
}
} else {
// TODO support <4.0 index
panic("Index format pre-4.0 not supported yet")
}
checksumNow := int64(input.Checksum())
checksumThen, err := input.ReadLong()
if err != nil {
return err
}
if checksumNow != checksumThen {
return errors.New(fmt.Sprintf("checksum mismatch in segments file (resource: %v)", input))
}
success = true
return nil
}
