func TestReadFieldInfos(t *testing.T) {
path := "../search/testdata/osx/belfrysample"
d, err := store.OpenFSDirectory(path)
if err != nil {
t.Error(err)
}
ctx := store.NewIOContextBool(false)
cd, err := store.NewCompoundFileDirectory(d, "_0.cfs", ctx, false)
if err != nil {
t.Error(err)
}
fis, err := Lucene42FieldInfosReader(cd, "_0", store.IO_CONTEXT_READONCE)
if err != nil {
t.Error(err)
}
if !fis.hasNorms || fis.hasDocValues {
t.Errorf("hasNorms must be true and hasDocValues must be false, but found %v", fis)
}
}
func newSegmentCoreReaders(owner *SegmentReader, dir store.Directory, si SegmentInfoPerCommit,
context store.IOContext, termsIndexDivisor int) (self SegmentCoreReaders, err error) {
if termsIndexDivisor == 0 {
panic("indexDivisor must be < 0 (don't load terms index) or greater than 0 (got 0)")
}
log.Printf("Initializing SegmentCoreReaders from directory: %v", dir)
self = SegmentCoreReaders{refCount: 1}
log.Print("Initializing listeners...")
self.addListener = make(chan CoreClosedListener)
self.removeListener = make(chan CoreClosedListener)
self.notifyListener = make(chan *SegmentReader)
// TODO re-enable later
go func() { // ensure listners are synchronized
coreClosedListeners := make([]CoreClosedListener, 0)
isRunning := true
var listener CoreClosedListener
for isRunning {
log.Print("Listening for events...")
select {
case listener = <-self.addListener:
coreClosedListeners = append(coreClosedListeners, listener)
case listener = <-self.removeListener:
n := len(coreClosedListeners)
for i, v := range coreClosedListeners {
if v == listener {
newListeners := make([]CoreClosedListener, 0, n-1)
newListeners = append(newListeners, coreClosedListeners[0:i]...)
newListeners = append(newListeners, coreClosedListeners[i+1:]...)
coreClosedListeners = newListeners
break
}
}
case owner := <-self.notifyListener:
log.Print("Shutting down SegmentCoreReaders...")
isRunning = false
for _, v := range coreClosedListeners {
v.onClose(owner)
}
}
}
log.Print("Listeners are done.")
}()
success := false
defer func() {
if !success {
log.Print("Failed to initialize SegmentCoreReaders.")
self.decRef()
}
}()
codec := si.info.codec
log.Print("Obtaining CFS Directory...")
var cfsDir store.Directory // confusing name: if (cfs) its the cfsdir, otherwise its the segment's directory.
if si.info.isCompoundFile {
log.Print("Detected CompoundFile.")
name := util.SegmentFileName(si.info.name, "", store.COMPOUND_FILE_EXTENSION)
self.cfsReader, err = store.NewCompoundFileDirectory(dir, name, context, false)
if err != nil {
return self, err
}
log.Printf("CompoundFileDirectory: %v", self.cfsReader)
cfsDir = self.cfsReader
} else {
cfsDir = dir
}
log.Printf("CFS Directory: %v", cfsDir)
log.Print("Reading FieldInfos...")
self.fieldInfos, err = codec.ReadFieldInfos(cfsDir, si.info.name, store.IO_CONTEXT_READONCE)
if err != nil {
return self, err
}
self.termsIndexDivisor = termsIndexDivisor
log.Print("Obtaining SegmentReadState...")
segmentReadState := newSegmentReadState(cfsDir, si.info, self.fieldInfos, context, termsIndexDivisor)
// Ask codec for its Fields
log.Print("Obtaining FieldsProducer...")
self.fields, err = codec.GetFieldsProducer(segmentReadState)
if err != nil {
return self, err
}
// assert fields != null;
// ask codec for its Norms:
// TODO: since we don't write any norms file if there are no norms,
// kinda jaky to assume the codec handles the case of no norms file at all gracefully?!
if self.fieldInfos.hasDocValues {
log.Print("Obtaining DocValuesProducer...")
self.dvProducer, err = codec.GetDocValuesProducer(segmentReadState)
if err != nil {
return self, err
}
// assert dvProducer != null;
} else {
// self.dvProducer = nil
}
if self.fieldInfos.hasNorms {
log.Print("Obtaining NormsDocValuesProducer...")
self.normsProducer, err = codec.GetNormsDocValuesProducer(segmentReadState)
if err != nil {
return self, err
}
// assert normsProducer != null;
} else {
// self.normsProducer = nil
}
log.Print("Obtaining StoredFieldsReader...")
self.fieldsReaderOrig, err = si.info.codec.GetStoredFieldsReader(cfsDir, si.info, self.fieldInfos, context)
if err != nil {
return self, err
}
if self.fieldInfos.hasVectors { // open term vector files only as needed
log.Print("Obtaining TermVectorsReader...")
self.termVectorsReaderOrig, err = si.info.codec.GetTermVectorsReader(cfsDir, si.info, self.fieldInfos, context)
if err != nil {
return self, err
}
} else {
// self.termVectorsReaderOrig = nil
}
log.Print("Success")
success = true
// Must assign this at the end -- if we hit an
// exception above core, we don't want to attempt to
// purge the FieldCache (will hit NPE because core is
// not assigned yet).
self.owner = owner
return self, nil
}
