// TODO support IndexCommit func openStandardDirectoryReader(directory store.Directory, termInfosIndexDivisor int) (r DirectoryReader, err error) { log.Print("Initializing SegmentsFile...") obj, err := NewFindSegmentsFile(directory, func(segmentFileName string) (obj interface{}, err error) { sis := &SegmentInfos{} err = sis.Read(directory, segmentFileName) if err != nil { return nil, err } log.Printf("Found %v segments...", len(sis.Segments)) readers := make([]AtomicReader, len(sis.Segments)) for i := len(sis.Segments) - 1; i >= 0; i-- { sr, err := NewSegmentReader(sis.Segments[i], termInfosIndexDivisor, store.IO_CONTEXT_READ) readers[i] = sr if err != nil { rs := make([]io.Closer, len(readers)) for i, v := range readers { rs[i] = v } return nil, util.CloseWhileHandlingError(err, rs...) } } log.Printf("Obtained %v SegmentReaders.", len(readers)) return newStandardDirectoryReader(directory, readers, sis, termInfosIndexDivisor, false), nil }).run() if err != nil { return nil, err } return obj.(*StandardDirectoryReader), err }
/* Copies the file src to 'to' under the new file name dest. If you want to copy the entire source directory to the destination one, you can do so like this: var to Directory // the directory to copy to for _, file := range dir.ListAll() { dir.Copy(to, file, newFile, IO_CONTEXT_DEFAULT) // newFile can be either file, or a new name } NOTE: this method does not check whether dest exists and will overwrite it if it does. */ func (d *DirectoryImpl) Copy(to Directory, src, dest string, ctx IOContext) (err error) { var os IndexOutput var is IndexInput defer func() { var success = false defer func() { if !success { to.DeleteFile(dest) // ignore error } }() err = util.CloseWhileHandlingError(err, os, is) success = true }() os, err = to.CreateOutput(dest, ctx) if err != nil { return err } is, err = d.OpenInput(src, ctx) if err != nil { return err } err = os.CopyBytes(is, is.Length()) return }
func (p *StoredFieldsProcessor) flush(state SegmentWriteState) (err error) { numDocs := state.segmentInfo.DocCount() if numDocs > 0 { // It's possible that all documents seen in this segment hit // non-aborting errors, in which case we will not have yet init'd // the FieldsWriter: err = p.initFieldsWriter(state.context) if err == nil { err = p.fill(numDocs) } } if w := p.fieldsWriter; w != nil { var success = false defer func() { if success { err = util.CloseWhileHandlingError(err, w) } else { util.CloseWhileSuppressingError(w) } }() err = w.Finish(state.fieldInfos, numDocs) if err != nil { return err } success = true } return }
func (out *FSIndexOutput) Close() error { out.parent.onIndexOutputClosed(out) // only close the file if it has not been closed yet if out.isOpen { var err error defer func() { out.isOpen = false util.CloseWhileHandlingError(err, out.file) }() err = out.BufferedIndexOutput.Close() } return nil }
log.Printf("Reading FieldInfos from %v...", dir) fi = model.FieldInfos{} fileName := util.SegmentFileName(segment, "", LUCENE42_FI_EXTENSION) log.Printf("Segment: %v", fileName) input, err := dir.OpenInput(fileName, context) if err != nil { return fi, err } log.Printf("Reading %v", input) success := false defer func() { if success { input.Close() } else { util.CloseWhileHandlingError(err, input) } }() _, err = codec.CheckHeader(input, LUCENE42_FI_CODEC_NAME, LUCENE42_FI_FORMAT_START, LUCENE42_FI_FORMAT_CURRENT) if err != nil { return fi, err } size, err := input.ReadVInt() //read in the size if err != nil { return fi, err }
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 }