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...))