/* 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 }
func (w *Lucene40SegmentInfoWriter) Write(dir store.Directory, si *SegmentInfo, fis FieldInfos, ctx store.IOContext) (err error) { filename := util.SegmentFileName(si.Name, "", LUCENE40_SI_EXTENSION) si.AddFile(filename) var output store.IndexOutput output, err = dir.CreateOutput(filename, ctx) if err != nil { return err } var success = false defer func() { if !success { util.CloseWhileSuppressingError(output) si.Dir.DeleteFile(filename) // ignore error } else { err = mergeError(err, output.Close()) } }() err = codec.WriteHeader(output, LUCENE40_CODEC_NAME, LUCENE40_VERSION_CURRENT) if err != nil { return err } // Write the Lucene version that created this segment, since 3.1 err = store.Stream(output).WriteString(si.Version().String()). WriteInt(int32(si.DocCount())). WriteByte(func() byte { if si.IsCompoundFile() { return SEGMENT_INFO_YES } return byte((SEGMENT_INFO_NO + 256) % 256) // Go byte is non-negative, unlike Java }()).WriteStringStringMap(si.Diagnostics()). WriteStringStringMap(map[string]string{}). WriteStringSet(si.Files()).Close() if err != nil { return err } success = true return nil }
func (w *MockDirectoryWrapper) _crash() error { w.crashed = true w.openFiles = make(map[string]int) w.openFilesForWrite = make(map[string]bool) w.openFilesDeleted = make(map[string]bool) files := w.unSyncedFiles w.unSyncedFiles = make(map[string]bool) // first force-close all files, so we can corrupt on windows etc. // clone the file map, as these guys want to remove themselves on close. m := make(map[io.Closer]error) for k, v := range w.openFileHandles { m[k] = v } for f, _ := range m { f.Close() // ignore error } for name, _ := range files { var action string var err error switch w.randomState.Intn(5) { case 0: action = "deleted" err = w.deleteFile(name, true) case 1: action = "zeroes" // Zero out file entirely var length int64 length, err = w.FileLength(name) if err == nil { zeroes := make([]byte, 256) var upto int64 = 0 var out store.IndexOutput out, err = w.BaseDirectoryWrapperImpl.CreateOutput(name, NewDefaultIOContext(w.randomState)) if err == nil { for upto < length && err == nil { limit := length - upto if int64(len(zeroes)) < limit { limit = int64(len(zeroes)) } err = out.WriteBytes(zeroes[:limit]) upto += limit } if err == nil { err = out.Close() } } } case 2: action = "partially truncated" // Partially Truncate the file: // First, make temp file and copy only half this file over: var tempFilename string for { tempFilename = fmt.Sprintf("%v", w.randomState.Int()) if !w.BaseDirectoryWrapperImpl.FileExists(tempFilename) { break } } var tempOut store.IndexOutput if tempOut, err = w.BaseDirectoryWrapperImpl.CreateOutput(tempFilename, NewDefaultIOContext(w.randomState)); err == nil { var ii store.IndexInput if ii, err = w.BaseDirectoryWrapperImpl.OpenInput(name, NewDefaultIOContext(w.randomState)); err == nil { if err = tempOut.CopyBytes(ii, ii.Length()/2); err == nil { if err = tempOut.Close(); err == nil { if err = ii.Close(); err == nil { // Delete original and copy bytes back: if err = w.deleteFile(name, true); err == nil { var out store.IndexOutput if out, err = w.BaseDirectoryWrapperImpl.CreateOutput(name, NewDefaultIOContext(w.randomState)); err == nil { if ii, err = w.BaseDirectoryWrapperImpl.OpenInput(tempFilename, NewDefaultIOContext(w.randomState)); err == nil { if err = out.CopyBytes(ii, ii.Length()); err == nil { if err = out.Close(); err == nil { if err = ii.Close(); err == nil { err = w.deleteFile(tempFilename, true) } } } } } } } } } } } case 3: // the file survived intact: action = "didn't change" default: action = "fully truncated" // totally truncate the file to zero bytes if err = w.deleteFile(name, true); err == nil { var out store.IndexOutput if out, err = w.BaseDirectoryWrapperImpl.CreateOutput(name, NewDefaultIOContext(w.randomState)); err == nil { if err = out.SetLength(0); err == nil { err = out.Close() } } } } if err != nil { return err } if VERBOSE { log.Printf("MockDirectoryWrapper: %v unsynced file: %v", action, name) } } return nil }
} } var Lucene46FieldInfosWriter = func(dir store.Directory, segName, suffix string, infos FieldInfos, ctx store.IOContext) (err error) { filename := util.SegmentFileName(segName, suffix, FI_EXTENSION) var output store.IndexOutput if output, err = dir.CreateOutput(filename, ctx); err != nil { return } var success = false defer func() { if success { err = output.Close() } else { util.CloseWhileSuppressingError(output) } }() if err = codec.WriteHeader(output, FI_CODEC_NAME, FI_FORMAT_CURRENT); err != nil { return } if err = output.WriteVInt(int32(infos.Size())); err != nil { return } for _, fi := range infos.Values { indexOptions := fi.IndexOptions() bits := byte(0) if fi.HasVectors() {