func (w *Lucene41PostingsWriter) Close() (err error) { var success = false defer func() { if success { err = util.Close(w.docOut, w.posOut, w.payOut) } else { util.CloseWhileSuppressingError(w.docOut, w.posOut, w.payOut) } w.docOut = nil w.posOut = nil w.payOut = nil }() if err == nil && w.docOut != nil { err = codec.WriteFooter(w.docOut) } if err == nil && w.posOut != nil { err = codec.WriteFooter(w.posOut) } if err == nil && w.payOut != nil { err = codec.WriteFooter(w.payOut) } if err != nil { return } success = true return nil }
func (nc *NormsConsumer) Close() (err error) { var success = false defer func() { if success { err = util.Close(nc.data, nc.meta) } else { util.CloseWhileSuppressingError(nc.data, nc.meta) } }() if nc.meta != nil { if err = nc.meta.WriteVInt(-1); err != nil { // write EOF marker return } if err = codec.WriteFooter(nc.meta); err != nil { // write checksum return } } if nc.data != nil { if err = codec.WriteFooter(nc.data); err != nil { // write checksum return } } success = true return nil }
func (w *BlockTreeTermsWriter) Close() (err error) { var success = false defer func() { if success { util.Close(w.out, w.indexOut, w.postingsWriter) } else { util.CloseWhileSuppressingError(w.out, w.indexOut, w.postingsWriter) } }() dirStart := w.out.FilePointer() indexDirStart := w.indexOut.FilePointer() if err = w.out.WriteVInt(int32(len(w.fields))); err != nil { return } for _, field := range w.fields { // fmt.Printf(" field %v %v terms\n", field.fieldInfo.Name, field.numTerms) if err = w.out.WriteVInt(field.fieldInfo.Number); err == nil { assert(field.numTerms > 0) if err = w.out.WriteVLong(field.numTerms); err == nil { if err = w.out.WriteVInt(int32(len(field.rootCode))); err == nil { err = w.out.WriteBytes(field.rootCode) if err == nil && field.fieldInfo.IndexOptions() != INDEX_OPT_DOCS_ONLY { err = w.out.WriteVLong(field.sumTotalTermFreq) } if err == nil { if err = w.out.WriteVLong(field.sumDocFreq); err == nil { if err = w.out.WriteVInt(int32(field.docCount)); err == nil { if err = w.out.WriteVInt(int32(field.longsSize)); err == nil { if err = w.indexOut.WriteVLong(field.indexStartFP); err == nil { if err = writeBytesRef(w.out, field.minTerm); err == nil { err = writeBytesRef(w.out, field.maxTerm) } } } } } } } } } } if err == nil { if err = w.writeTrailer(w.out, dirStart); err == nil { if err = codec.WriteFooter(w.out); err == nil { if err = w.writeIndexTrailer(w.indexOut, indexDirStart); err == nil { if err = codec.WriteFooter(w.indexOut); err == nil { success = true } } } } } return }
func (w *CompoundFileWriter) writeEntryTable(entries map[string]*FileEntry, entryOut IndexOutput) (err error) { if err = codec.WriteHeader(entryOut, CFD_ENTRY_CODEC, CFD_VERSION_CURRENT); err == nil { if err = entryOut.WriteVInt(int32(len(entries))); err == nil { var names []string for name, _ := range entries { names = append(names, name) } sort.Strings(names) for _, name := range names { // for _, fe := range entries { fe := entries[name] if err = Stream(entryOut). WriteString(util.StripSegmentName(fe.file)). WriteLong(fe.offset). WriteLong(fe.length). Close(); err != nil { break } } } } if err == nil { err = codec.WriteFooter(entryOut) } return err }
/* A utility for writing the SEGMENTS_GEN file to a Directory. NOTE: this is an internal utility which is kept public so that it's accessible by code from other packages. You should avoid calling this method unless you're absolutely sure what you're doing! */ func writeSegmentsGen(dir store.Directory, generation int64) { if err := func() (err error) { var genOutput store.IndexOutput genOutput, err = dir.CreateOutput(INDEX_FILENAME_SEGMENTS_GEN, store.IO_CONTEXT_READONCE) if err != nil { return err } defer func() { err = mergeError(err, genOutput.Close()) err = mergeError(err, dir.Sync([]string{INDEX_FILENAME_SEGMENTS_GEN})) }() if err = genOutput.WriteInt(FORMAT_SEGMENTS_GEN_CURRENT); err == nil { if err = genOutput.WriteLong(generation); err == nil { if err = genOutput.WriteLong(generation); err == nil { err = codec.WriteFooter(genOutput) } } } return err }(); err != nil { // It's OK if we fail to write this file since it's used only as // one of the retry fallbacks. dir.DeleteFile(INDEX_FILENAME_SEGMENTS_GEN) // Ignore error; this file is only used in a retry fallback on init } }
/* Writes this vector to the file name in Directory d, in a format that can be read by the constructor BitVector(Directory, String, IOContext) */ func (bv *BitVector) Write(d store.Directory, name string, ctx store.IOContext) (err error) { assert(reflect.TypeOf(d).Name() != "CompoundFileDirectory") var output store.IndexOutput if output, err = d.CreateOutput(name, ctx); err != nil { return err } defer func() { err = mergeError(err, output.Close()) }() if err = output.WriteInt(-2); err != nil { return err } if err = codec.WriteHeader(output, CODEC, BV_VERSION_CURRENT); err != nil { return err } if bv.isSparse() { // sparse bit-set more efficiently saved as d-gaps. err = bv.writeClearedDgaps(output) } else { err = bv.writeBits(output) } if err != nil { return err } if err = codec.WriteFooter(output); err != nil { return err } bv.assertCount() return nil }
/* Closes all resouces and writes the entry table */ func (w *CompoundFileWriter) Close() (err error) { if w.closed { fmt.Println("CompoundFileWriter is already closed.") return nil } // TODO this code should clean up after itself (remove partial .cfs/.cfe) if err = func() (err error) { var success = false defer func() { if success { util.Close(w.dataOut) } else { util.CloseWhileSuppressingError(w.dataOut) } }() assert2(w.pendingEntries.Len() == 0 && !w.outputTaken.Get(), "CFS has pending open files") w.closed = true // open the compound stream; we can safely use IO_CONTEXT_DEFAULT // here because this will only open the output if no file was // added to the CFS _, err = w.output(IO_CONTEXT_DEFAULT) if err != nil { return } assert(w.dataOut != nil) err = codec.WriteFooter(w.dataOut) if err != nil { return } success = true return nil }(); err != nil { return } var entryTableOut IndexOutput var success = false defer func() { if success { util.Close(entryTableOut) } else { util.CloseWhileSuppressingError(entryTableOut) } }() entryTableOut, err = w.directory.CreateOutput(w.entryTableName, IO_CONTEXT_DEFAULT) if err != nil { return } err = w.writeEntryTable(w.entries, entryTableOut) if err != nil { return } success = true return }
func (w *StoredFieldsIndexWriter) finish(numDocs int, maxPointer int64) (err error) { assert(w != nil) assert2(numDocs == w.totalDocs, "Expected %v docs, but got %v", numDocs, w.totalDocs) if w.blockChunks > 0 { if err = w.writeBlock(); err != nil { return } } if err = w.fieldsIndexOut.WriteVInt(0); err != nil { // end marker return } if err = w.fieldsIndexOut.WriteVLong(maxPointer); err != nil { return } return codec.WriteFooter(w.fieldsIndexOut) }
func (w *CompressingStoredFieldsWriter) Finish(fis model.FieldInfos, numDocs int) (err error) { if w == nil { return errors.New("Nil class pointer encountered.") } assert2(w.indexWriter != nil, "already closed?") if w.numBufferedDocs > 0 { if err = w.flush(); err != nil { return err } } else { assert(w.bufferedDocs.length == 0) } assert2(w.docBase == numDocs, "Wrote %v docs, finish called with numDocs=%v", w.docBase, numDocs) if err = w.indexWriter.finish(numDocs, w.fieldsStream.FilePointer()); err != nil { return err } if err = codec.WriteFooter(w.fieldsStream); err != nil { return err } assert(w.bufferedDocs.length == 0) return nil }
func (sis *SegmentInfos) finishCommit(dir store.Directory) (fileName string, err error) { assert(dir != nil) assert2(sis.pendingSegnOutput != nil, "prepareCommit was not called") if err = func() error { var success = false defer func() { if !success { // Closes pendingSegnOutput & delets partial segments_N: sis.rollbackCommit(dir) } else { err := func() error { var success = false defer func() { if !success { // Closes pendingSegnOutput & delets partial segments_N: sis.rollbackCommit(dir) } else { sis.pendingSegnOutput = nil } }() err := sis.pendingSegnOutput.Close() success = err == nil return err }() assertn(err == nil, "%v", err) // no shadow } }() if err := codec.WriteFooter(sis.pendingSegnOutput); err != nil { return err } success = true return nil }(); err != nil { return } // NOTE: if we crash here, we have left a segments_N file in the // directory in a possibly corrupt state (if some bytes made it to // stable storage and others didn't). But, the segments_N file // includes checksum at the end, which should catch this case. So // when a reader tries to read it, it will return an index corrupt // error, which should cause the retry logic in SegmentInfos to // kick in and load the last good (previous) segments_N-1 file. fileName = util.FileNameFromGeneration(INDEX_FILENAME_SEGMENTS, "", sis.generation) if err = func() error { var success = false defer func() { if !success { dir.DeleteFile(fileName) // suppress error so we keep returning the original error } }() err := dir.Sync([]string{fileName}) success = err == nil return err }(); err != nil { return } sis.lastGeneration = sis.generation writeSegmentsGen(dir, sis.generation) return }
// pack the DV types in one byte dv := byte(fi.DocValuesType()) nrm := byte(fi.NormType()) assert((dv&(^byte(0xF))) == 0 && (nrm&(^byte(0x0F))) == 0) val := (0xff & ((nrm << 4) | dv)) if err = output.WriteByte(val); err == nil { if err = output.WriteLong(fi.DocValuesGen()); err == nil { err = output.WriteStringStringMap(fi.Attributes()) } } if err != nil { return } } if err = codec.WriteFooter(output); err != nil { return } success = true return nil } func assert(ok bool) { if !ok { panic("assert fail") } } func assert2(ok bool, msg string, args ...interface{}) { if !ok { panic(fmt.Sprintf(msg, args...))