couchbase / moss / 174

pending completion

Build # 174

Build Type

push

travis-ci

Committed by

abhinavdangeti

Commit Message

MB-22542: Adding public APIs to fetch header/footer length

+ HeaderLength()
+ Footer::Length()

Change-Id: If01b80aa1
Reviewed-on: http://review.couchbase.org/73033
Reviewed-by: Steve Yen <steve.yen@gmail.com>
Tested-by: abhinav dangeti <abhinav@couchbase.com>

Run Details

18 of 18 new or added lines in 3 files covered. (100.0%)

2702 of 3387 relevant lines covered (79.78%)

8493.55 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

68.98

/store_footer.go

//  Copyright (c) 2016 Couchbase, Inc.
//  Licensed under the Apache License, Version 2.0 (the "License");
//  you may not use this file except in compliance with the
//  License. You may obtain a copy of the License at
//    http://www.apache.org/licenses/LICENSE-2.0
//  Unless required by applicable law or agreed to in writing,
//  software distributed under the License is distributed on an "AS
//  IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
//  express or implied. See the License for the specific language
//  governing permissions and limitations under the License.

package moss

import (
        "bytes"
        "encoding/binary"
        "encoding/json"
        "fmt"

        "github.com/edsrzf/mmap-go"
)

func (s *Store) persistFooter(file File, footer *Footer, sync bool) error {
        if sync {
                err := file.Sync()
                if err != nil {
                        return err
                }
        }

        err := s.persistFooterUnsynced(file, footer)
        if err != nil {
                return err
        }

        if sync {
                return file.Sync()
        }

        return nil
}

func (s *Store) persistFooterUnsynced(file File, footer *Footer) error {
        jBuf, err := json.Marshal(footer)
        if err != nil {
                return err
        }

        finfo, err := file.Stat()
        if err != nil {
                return err
        }

        footerPos := pageAlign(finfo.Size())
        footerLen := footerBegLen + len(jBuf) + footerEndLen

        footerBuf := bytes.NewBuffer(make([]byte, 0, footerLen))
        footerBuf.Write(STORE_MAGIC_BEG)
        footerBuf.Write(STORE_MAGIC_BEG)
        binary.Write(footerBuf, STORE_ENDIAN, uint32(STORE_VERSION))
        binary.Write(footerBuf, STORE_ENDIAN, uint32(footerLen))
        footerBuf.Write(jBuf)
        binary.Write(footerBuf, STORE_ENDIAN, footerPos)
        binary.Write(footerBuf, STORE_ENDIAN, uint32(footerLen))
        footerBuf.Write(STORE_MAGIC_END)
        footerBuf.Write(STORE_MAGIC_END)

        footerWritten, err := file.WriteAt(footerBuf.Bytes(), footerPos)
        if err != nil {
                return err
        }
        if footerWritten != len(footerBuf.Bytes()) {
                return fmt.Errorf("store: persistFooter error writing all footerBuf")
        }

        footer.fileName = finfo.Name()
        footer.filePos = footerPos

        return nil
}

// --------------------------------------------------------

// ReadFooter reads the last valid Footer from a file.
func ReadFooter(options *StoreOptions, file File) (*Footer, error) {
        finfo, err := file.Stat()
        if err != nil {
                return nil, err
        }

        fref := &FileRef{file: file, refs: 1}

        f, err := ScanFooter(options, fref, finfo.Name(), finfo.Size())
        if err != nil {
                return nil, err
        }

        fref.DecRef() // ScanFooter added its own ref-counts on success.

        return f, err
}

// --------------------------------------------------------

// ScanFooter scans a file backwards from the given pos for a valid
// Footer, adding ref-counts to fref on success.
func ScanFooter(options *StoreOptions, fref *FileRef, fileName string,
        pos int64) (*Footer, error) {
        footerEnd := make([]byte, footerEndLen)
        for {
                for { // Scan backwards for STORE_MAGIC_END, which might be a potential footer.
                        if pos <= int64(footerBegLen+footerEndLen) {
                                return nil, ErrNoValidFooter
                        }
                        n, err := fref.file.ReadAt(footerEnd, pos-int64(footerEndLen))
                        if err != nil {
                                return nil, err
                        }
                        if n != footerEndLen {
                                return nil, fmt.Errorf("store: read footer too small")
                        }
                        if bytes.Equal(STORE_MAGIC_END, footerEnd[8+4:8+4+lenMagicEnd]) &&
                                bytes.Equal(STORE_MAGIC_END, footerEnd[8+4+lenMagicEnd:]) {
                                break
                        }

                        pos-- // TODO: optimizations to scan backwards faster.
                }

                // Read and check the potential footer.
                footerEndBuf := bytes.NewBuffer(footerEnd)

                var offset int64
                if err := binary.Read(footerEndBuf, STORE_ENDIAN, &offset); err != nil {
                        return nil, err
                }

                var length uint32
                if err := binary.Read(footerEndBuf, STORE_ENDIAN, &length); err != nil {
                        return nil, err
                }

                if offset > 0 &&
                        offset < pos-int64(footerBegLen+footerEndLen) &&
                        length == uint32(pos-offset) {
                        data := make([]byte, pos-offset-int64(footerEndLen))

                        n, err := fref.file.ReadAt(data, offset)
                        if err != nil {
                                return nil, err
                        }
                        if n != len(data) {
                                return nil, fmt.Errorf("store: read footer data too small")
                        }

                        if bytes.Equal(STORE_MAGIC_BEG, data[:lenMagicBeg]) &&
                                bytes.Equal(STORE_MAGIC_BEG, data[lenMagicBeg:2*lenMagicBeg]) {
                                b := bytes.NewBuffer(data[2*lenMagicBeg:])

                                var version uint32
                                if err := binary.Read(b, STORE_ENDIAN, &version); err != nil {
                                        return nil, err
                                }
                                if version != STORE_VERSION {
                                        return nil, fmt.Errorf("store: version mismatch, "+
                                                "current: %v != found: %v", STORE_VERSION, version)
                                }

                                var length0 uint32
                                if err := binary.Read(b, STORE_ENDIAN, &length0); err != nil {
                                        return nil, err
                                }
                                if length0 != length {
                                        return nil, fmt.Errorf("store: length mismatch, "+
                                                "wanted: %v != found: %v", length0, length)
                                }

                                f := &Footer{refs: 1, fileName: fileName, filePos: offset}

                                err = json.Unmarshal(data[2*lenMagicBeg+4+4:], f)
                                if err != nil {
                                        return nil, err
                                }

                                err = f.loadSegments(options, fref)
                                if err != nil {
                                        return nil, err
                                }

                                return f, nil
                        } // Else, perhaps file was unlucky in having STORE_MAGIC_END's.
                } // Else, perhaps a persist file was stored in a file.

                pos-- // Footer was invalid, so keep scanning.
        }
}

// --------------------------------------------------------

// loadSegments() loads the segments of a footer, which must not be
// already loaded.  The footer adds new ref-counts to the fref on
// success.  The footer will be in an already closed state on error.
func (f *Footer) loadSegments(options *StoreOptions, fref *FileRef) (err error) {
        if f.ss != nil && f.ss.a != nil {
                return nil
        }

        osFile := ToOsFile(fref.file)
        if osFile == nil {
                return fmt.Errorf("store: loadSegments convert to os.File error")
        }

        a := make([]Segment, len(f.SegmentLocs))

        // Track mrefs that we need to DecRef() if there's an error.
        mrefs := make([]*mmapRef, 0, len(f.SegmentLocs))

        onError := func() {
                for _, mref := range mrefs {
                        mref.DecRef()
                }
        }

        for i := range f.SegmentLocs {
                sloc := &f.SegmentLocs[i]

                mref := sloc.mref
                if mref != nil {
                        if mref.fref != fref {
                                onError()
                                return fmt.Errorf("store: loadSegments fref mismatch")
                        }

                        mref.AddRef()
                } else {
                        // We persist kvs before buf, so KvsOffset < BufOffset.
                        begOffset := int64(sloc.KvsOffset)
                        endOffset := int64(sloc.BufOffset + sloc.BufBytes)

                        nbytes := int(endOffset - begOffset)

                        // Some platforms (windows) only support mmap()'ing at an
                        // allocation granularity that's != to a page size, so
                        // calculate the actual offset/nbytes to use.
                        begOffsetActual := pageOffset(begOffset, int64(AllocationGranularity))
                        begOffsetDelta := int(begOffset - begOffsetActual)
                        nbytesActual := nbytes + begOffsetDelta

                        mm, err := mmap.MapRegion(osFile, nbytesActual, mmap.RDONLY, 0, begOffsetActual)
                        if err != nil {
                                onError()
                                return fmt.Errorf("store: loadSegments mmap.Map(), err: %v", err)
                        }

                        fref.AddRef() // New mref owns 1 fref ref-count.

                        buf := mm[begOffsetDelta : begOffsetDelta+nbytes]

                        sloc.mref = &mmapRef{fref: fref, mm: mm, buf: buf, refs: 1}

                        mref = sloc.mref
                }

                mrefs = append(mrefs, mref)

                segmentLoader, exists := SegmentLoaders[sloc.Kind]
                if !exists || segmentLoader == nil {
                        onError()
                        return fmt.Errorf("store: unknown SegmentLoc kind, sloc: %+v", sloc)
                }

                var kvs []uint64
                var buf []byte

                if sloc.KvsBytes > 0 {
                        if sloc.KvsBytes > uint64(len(mref.buf)) {
                                onError()
                                return fmt.Errorf("store_footer: KvsOffset/KvsBytes too big,"+
                                        " len(mref.buf): %d, sloc: %+v, footer: %+v,"+
                                        " f.SegmentLocs: %+v, i: %d, options: %v",
                                        len(mref.buf), sloc, f, f.SegmentLocs, i, options)
                        }

                        kvsBytes := mref.buf[0:sloc.KvsBytes]
                        kvs, err = ByteSliceToUint64Slice(kvsBytes)
                        if err != nil {
                                onError()
                                return err
                        }
                }

                if sloc.BufBytes > 0 {
                        bufStart := sloc.BufOffset - sloc.KvsOffset
                        if bufStart+sloc.BufBytes > uint64(len(mref.buf)) {
                                onError()
                                return fmt.Errorf("store_footer: BufOffset/BufBytes too big,"+
                                        " len(mref.buf): %d, sloc: %+v, footer: %+v,"+
                                        " f.SegmentLocs: %+v, i: %d, options: %v",
                                        len(mref.buf), sloc, f, f.SegmentLocs, i, options)
                        }

                        buf = mref.buf[bufStart : bufStart+sloc.BufBytes]
                }

                seg, err := segmentLoader(sloc, kvs, buf)
                if err != nil {
                        onError()
                        return err
                }

                a[i] = seg
        }

        f.ss = &segmentStack{options: &options.CollectionOptions, a: a, refs: 1}

        return nil
}

// --------------------------------------------------------

func (f *Footer) Close() error {
        f.DecRef()
        return nil
}

func (f *Footer) AddRef() {
        f.m.Lock()
        f.refs++
        f.m.Unlock()
}

func (f *Footer) DecRef() {
        f.m.Lock()
        f.refs--
        if f.refs <= 0 {
                f.SegmentLocs.DecRef()
                f.SegmentLocs = nil
                f.ss = nil
        }
        f.m.Unlock()
}

func (f *Footer) Length() uint64 {
        jBuf, err := json.Marshal(f)
        if err != nil {
                return 0
        }

        footerLen := footerBegLen + len(jBuf) + footerEndLen
        return uint64(footerLen)
}

// --------------------------------------------------------

// SegmentStack() returns the current SegmentLocs and segmentStack for
// a footer, while also incrementing the ref-count on the footer.  The
// caller must DecRef() the footer when done.
func (f *Footer) SegmentStack() (SegmentLocs, *segmentStack) {
        f.m.Lock()

        f.refs++

        slocs, ss := f.SegmentLocs, f.ss

        f.m.Unlock()

        return slocs, ss
}

// --------------------------------------------------------

// Get retrieves a val from the footer, and will return nil val
// if the entry does not exist in the footer.
func (f *Footer) Get(key []byte, readOptions ReadOptions) ([]byte, error) {
        _, ss := f.SegmentStack()
        if ss == nil {
                f.DecRef()
                return nil, nil
        }

        rv, err := ss.Get(key, readOptions)
        if err == nil && rv != nil && !readOptions.NoCopyValue {
                rv = append(make([]byte, 0, len(rv)), rv...) // Copy.
        }

        f.DecRef()

        return rv, err
}

// StartIterator returns a new Iterator instance on this footer.
//
// On success, the returned Iterator will be positioned so that
// Iterator.Current() will either provide the first entry in the
// range or ErrIteratorDone.
//
// A startKeyIncl of nil means the logical "bottom-most" possible key
// and an endKeyExcl of nil means the logical "top-most" possible key.
func (f *Footer) StartIterator(startKeyIncl, endKeyExcl []byte,
        iteratorOptions IteratorOptions) (Iterator, error) {
        _, ss := f.SegmentStack()
        if ss == nil {
                f.DecRef()
                return nil, nil
        }

        iter, err := ss.StartIterator(startKeyIncl, endKeyExcl, iteratorOptions)
        if err != nil || iter == nil {
                f.DecRef()
                return nil, err
        }

        initCloser, ok := iter.(InitCloser)
        if !ok || initCloser == nil {
                iter.Close()
                f.DecRef()
                return nil, ErrUnexpected
        }

        err = initCloser.InitCloser(f)
        if err != nil {
                iter.Close()
                f.DecRef()
                return nil, err
        }

        return iter, nil
}

1	// Copyright (c) 2016 Couchbase, Inc.
2	// Licensed under the Apache License, Version 2.0 (the "License");
3	// you may not use this file except in compliance with the
4	// License. You may obtain a copy of the License at
5	// http://www.apache.org/licenses/LICENSE-2.0
6	// Unless required by applicable law or agreed to in writing,
7	// software distributed under the License is distributed on an "AS
8	// IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
9	// express or implied. See the License for the specific language
10	// governing permissions and limitations under the License.
11
12	package moss
13
14	import (
15	"bytes"
16	"encoding/binary"
17	"encoding/json"
18	"fmt"
19
20	"github.com/edsrzf/mmap-go"
21	)
22
23	func (s Store) persistFooter(file File, footer Footer, sync bool) error {	124✔
24	if sync {	247✔
25	err := file.Sync()	123✔
26	if err != nil {	123✔
27	return err	×
28	}	×
29	}
30
31	err := s.persistFooterUnsynced(file, footer)	124✔
32	if err != nil {	124✔
33	return err	×
34	}	×
35
36	if sync {	247✔
37	return file.Sync()	123✔
38	}	123✔
39
40	return nil	1✔
41	}
42
43	func (s Store) persistFooterUnsynced(file File, footer Footer) error {	124✔
44	jBuf, err := json.Marshal(footer)	124✔
45	if err != nil {	124✔
46	return err	×
47	}	×
48
49	finfo, err := file.Stat()	124✔
50	if err != nil {	124✔
51	return err	×
52	}	×
53
54	footerPos := pageAlign(finfo.Size())	124✔
55	footerLen := footerBegLen + len(jBuf) + footerEndLen	124✔
56		124✔
57	footerBuf := bytes.NewBuffer(make([]byte, 0, footerLen))	124✔
58	footerBuf.Write(STORE_MAGIC_BEG)	124✔
59	footerBuf.Write(STORE_MAGIC_BEG)	124✔
60	binary.Write(footerBuf, STORE_ENDIAN, uint32(STORE_VERSION))	124✔
61	binary.Write(footerBuf, STORE_ENDIAN, uint32(footerLen))	124✔
62	footerBuf.Write(jBuf)	124✔
63	binary.Write(footerBuf, STORE_ENDIAN, footerPos)	124✔
64	binary.Write(footerBuf, STORE_ENDIAN, uint32(footerLen))	124✔
65	footerBuf.Write(STORE_MAGIC_END)	124✔
66	footerBuf.Write(STORE_MAGIC_END)	124✔
67		124✔
68	footerWritten, err := file.WriteAt(footerBuf.Bytes(), footerPos)	124✔
69	if err != nil {	124✔
70	return err	×
71	}	×
72	if footerWritten != len(footerBuf.Bytes()) {	124✔
73	return fmt.Errorf("store: persistFooter error writing all footerBuf")	×
74	}	×
75
76	footer.fileName = finfo.Name()	124✔
77	footer.filePos = footerPos	124✔
78		124✔
79	return nil	124✔
80	}
81
82	// --------------------------------------------------------
83
84	// ReadFooter reads the last valid Footer from a file.
85	func ReadFooter(options StoreOptions, file File) (Footer, error) {	121✔
86	finfo, err := file.Stat()	121✔
87	if err != nil {	121✔
88	return nil, err	×
89	}	×
90
91	fref := &FileRef{file: file, refs: 1}	121✔
92		121✔
93	f, err := ScanFooter(options, fref, finfo.Name(), finfo.Size())	121✔
94	if err != nil {	125✔
95	return nil, err	4✔
96	}	4✔
97
98	fref.DecRef() // ScanFooter added its own ref-counts on success.	117✔
99		117✔
100	return f, err	117✔
101	}
102
103	// --------------------------------------------------------
104
105	// ScanFooter scans a file backwards from the given pos for a valid
106	// Footer, adding ref-counts to fref on success.
107	func ScanFooter(options StoreOptions, fref FileRef, fileName string,
108	pos int64) (*Footer, error) {	149✔
109	footerEnd := make([]byte, footerEndLen)	149✔
110	for {	298✔
111	for { // Scan backwards for STORE_MAGIC_END, which might be a potential footer.	356,875✔
112	if pos <= int64(footerBegLen+footerEndLen) {	356,743✔
113	return nil, ErrNoValidFooter	17✔
114	}	17✔
115	n, err := fref.file.ReadAt(footerEnd, pos-int64(footerEndLen))	356,709✔
116	if err != nil {	356,709✔
117	return nil, err	×
118	}	×
119	if n != footerEndLen {	356,709✔
120	return nil, fmt.Errorf("store: read footer too small")	×
121	}	×
122	if bytes.Equal(STORE_MAGIC_END, footerEnd[8+4:8+4+lenMagicEnd]) &&	356,709✔
123	bytes.Equal(STORE_MAGIC_END, footerEnd[8+4+lenMagicEnd:]) {	356,841✔
124	break	132✔
125	}
126
127	pos-- // TODO: optimizations to scan backwards faster.	356,577✔
128	}
129
130	// Read and check the potential footer.
131	footerEndBuf := bytes.NewBuffer(footerEnd)	132✔
132		132✔
133	var offset int64	132✔
134	if err := binary.Read(footerEndBuf, STORE_ENDIAN, &offset); err != nil {	132✔
135	return nil, err	×
136	}	×
137
138	var length uint32	132✔
139	if err := binary.Read(footerEndBuf, STORE_ENDIAN, &length); err != nil {	132✔
140	return nil, err	×
141	}	×
142
143	if offset > 0 &&	132✔
144	offset < pos-int64(footerBegLen+footerEndLen) &&	132✔
145	length == uint32(pos-offset) {	264✔
146	data := make([]byte, pos-offset-int64(footerEndLen))	132✔
147		132✔
148	n, err := fref.file.ReadAt(data, offset)	132✔
149	if err != nil {	132✔
150	return nil, err	×
151	}	×
152	if n != len(data) {	132✔
153	return nil, fmt.Errorf("store: read footer data too small")	×
154	}	×
155
156	if bytes.Equal(STORE_MAGIC_BEG, data[:lenMagicBeg]) &&	132✔
157	bytes.Equal(STORE_MAGIC_BEG, data[lenMagicBeg:2*lenMagicBeg]) {	264✔
158	b := bytes.NewBuffer(data[2*lenMagicBeg:])	132✔
159		132✔
160	var version uint32	132✔
161	if err := binary.Read(b, STORE_ENDIAN, &version); err != nil {	132✔
162	return nil, err	×
163	}	×
164	if version != STORE_VERSION {	132✔
165	return nil, fmt.Errorf("store: version mismatch, "+	×
166	"current: %v != found: %v", STORE_VERSION, version)	×
167	}	×
168
169	var length0 uint32	132✔
170	if err := binary.Read(b, STORE_ENDIAN, &length0); err != nil {	132✔
171	return nil, err	×
172	}	×
173	if length0 != length {	132✔
174	return nil, fmt.Errorf("store: length mismatch, "+	×
175	"wanted: %v != found: %v", length0, length)	×
176	}	×
177
178	f := &Footer{refs: 1, fileName: fileName, filePos: offset}	132✔
179		132✔
180	err = json.Unmarshal(data[2*lenMagicBeg+4+4:], f)	132✔
181	if err != nil {	132✔
182	return nil, err	×
183	}	×
184
185	err = f.loadSegments(options, fref)	132✔
186	if err != nil {	132✔
187	return nil, err	×
188	}	×
189
190	return f, nil	132✔
191	} // Else, perhaps file was unlucky in having STORE_MAGIC_END's.
192	} // Else, perhaps a persist file was stored in a file.
193
194	pos-- // Footer was invalid, so keep scanning.	×
195	}
196	}
197
198	// --------------------------------------------------------
199
200	// loadSegments() loads the segments of a footer, which must not be
201	// already loaded. The footer adds new ref-counts to the fref on
202	// success. The footer will be in an already closed state on error.
203	func (f Footer) loadSegments(options StoreOptions, fref *FileRef) (err error) {	181✔
204	if f.ss != nil && f.ss.a != nil {	181✔
205	return nil	×
206	}	×
207
208	osFile := ToOsFile(fref.file)	181✔
209	if osFile == nil {	181✔
210	return fmt.Errorf("store: loadSegments convert to os.File error")	×
211	}	×
212
213	a := make([]Segment, len(f.SegmentLocs))	181✔
214		181✔
215	// Track mrefs that we need to DecRef() if there's an error.	181✔
216	mrefs := make([]*mmapRef, 0, len(f.SegmentLocs))	181✔
217		181✔
218	onError := func() {	181✔
219	for _, mref := range mrefs {	×
220	mref.DecRef()	×
221	}	×
222	}
223
224	for i := range f.SegmentLocs {	488✔
225	sloc := &f.SegmentLocs[i]	307✔
226		307✔
227	mref := sloc.mref	307✔
228	if mref != nil {	406✔
229	if mref.fref != fref {	99✔
230	onError()	×
231	return fmt.Errorf("store: loadSegments fref mismatch")	×
232	}	×
233
234	mref.AddRef()	99✔
235	} else {	208✔
236	// We persist kvs before buf, so KvsOffset < BufOffset.	208✔
237	begOffset := int64(sloc.KvsOffset)	208✔
238	endOffset := int64(sloc.BufOffset + sloc.BufBytes)	208✔
239		208✔
240	nbytes := int(endOffset - begOffset)	208✔
241		208✔
242	// Some platforms (windows) only support mmap()'ing at an	208✔
243	// allocation granularity that's != to a page size, so	208✔
244	// calculate the actual offset/nbytes to use.	208✔
245	begOffsetActual := pageOffset(begOffset, int64(AllocationGranularity))	208✔
246	begOffsetDelta := int(begOffset - begOffsetActual)	208✔
247	nbytesActual := nbytes + begOffsetDelta	208✔
248		208✔
249	mm, err := mmap.MapRegion(osFile, nbytesActual, mmap.RDONLY, 0, begOffsetActual)	208✔
250	if err != nil {	208✔
251	onError()	×
252	return fmt.Errorf("store: loadSegments mmap.Map(), err: %v", err)	×
253	}	×
254
255	fref.AddRef() // New mref owns 1 fref ref-count.	208✔
256		208✔
257	buf := mm[begOffsetDelta : begOffsetDelta+nbytes]	208✔
258		208✔
259	sloc.mref = &mmapRef{fref: fref, mm: mm, buf: buf, refs: 1}	208✔
260		208✔
261	mref = sloc.mref	208✔
262	}
263
264	mrefs = append(mrefs, mref)	307✔
265		307✔
266	segmentLoader, exists := SegmentLoaders[sloc.Kind]	307✔
267	if !exists \|\| segmentLoader == nil {	307✔
268	onError()	×
269	return fmt.Errorf("store: unknown SegmentLoc kind, sloc: %+v", sloc)	×
270	}	×
271
272	var kvs []uint64	307✔
273	var buf []byte	307✔
274		307✔
275	if sloc.KvsBytes > 0 {	608✔
276	if sloc.KvsBytes > uint64(len(mref.buf)) {	301✔
277	onError()	×
278	return fmt.Errorf("store_footer: KvsOffset/KvsBytes too big,"+	×
279	" len(mref.buf): %d, sloc: %+v, footer: %+v,"+	×
280	" f.SegmentLocs: %+v, i: %d, options: %v",	×
281	len(mref.buf), sloc, f, f.SegmentLocs, i, options)	×
282	}	×
283
284	kvsBytes := mref.buf[0:sloc.KvsBytes]	301✔
285	kvs, err = ByteSliceToUint64Slice(kvsBytes)	301✔
286	if err != nil {	301✔
287	onError()	×
288	return err	×
289	}	×
290	}
291
292	if sloc.BufBytes > 0 {	608✔
293	bufStart := sloc.BufOffset - sloc.KvsOffset	301✔
294	if bufStart+sloc.BufBytes > uint64(len(mref.buf)) {	301✔
295	onError()	×
296	return fmt.Errorf("store_footer: BufOffset/BufBytes too big,"+	×
297	" len(mref.buf): %d, sloc: %+v, footer: %+v,"+	×
298	" f.SegmentLocs: %+v, i: %d, options: %v",	×
299	len(mref.buf), sloc, f, f.SegmentLocs, i, options)	×
300	}	×
301
302	buf = mref.buf[bufStart : bufStart+sloc.BufBytes]	301✔
303	}
304
305	seg, err := segmentLoader(sloc, kvs, buf)	307✔
306	if err != nil {	307✔
307	onError()	×
308	return err	×
309	}	×
310
311	a[i] = seg	307✔
312	}
313
314	f.ss = &segmentStack{options: &options.CollectionOptions, a: a, refs: 1}	181✔
315		181✔
316	return nil	181✔
317	}
318
319	// --------------------------------------------------------
320
321	func (f *Footer) Close() error {	506✔
322	f.DecRef()	506✔
323	return nil	506✔
324	}	506✔
325
326	func (f *Footer) AddRef() {	280✔
327	f.m.Lock()	280✔
328	f.refs++	280✔
329	f.m.Unlock()	280✔
330	}	280✔
331
332	func (f *Footer) DecRef() {	1,782✔
333	f.m.Lock()	1,782✔
334	f.refs--	1,782✔
335	if f.refs <= 0 {	2,000✔
336	f.SegmentLocs.DecRef()	218✔
337	f.SegmentLocs = nil	218✔
338	f.ss = nil	218✔
339	}	218✔
340	f.m.Unlock()	1,782✔
341	}
342
343	func (f *Footer) Length() uint64 {	3✔
344	jBuf, err := json.Marshal(f)	3✔
345	if err != nil {	3✔
346	return 0	×
347	}	×
348
349	footerLen := footerBegLen + len(jBuf) + footerEndLen	3✔
350	return uint64(footerLen)	3✔
351	}
352
353	// --------------------------------------------------------
354
355	// SegmentStack() returns the current SegmentLocs and segmentStack for
356	// a footer, while also incrementing the ref-count on the footer. The
357	// caller must DecRef() the footer when done.
358	func (f Footer) SegmentStack() (SegmentLocs, segmentStack) {	1,288✔
359	f.m.Lock()	1,288✔
360		1,288✔
361	f.refs++	1,288✔
362		1,288✔
363	slocs, ss := f.SegmentLocs, f.ss	1,288✔
364		1,288✔
365	f.m.Unlock()	1,288✔
366		1,288✔
367	return slocs, ss	1,288✔
368	}	1,288✔
369
370	// --------------------------------------------------------
371
372	// Get retrieves a val from the footer, and will return nil val
373	// if the entry does not exist in the footer.
374	func (f *Footer) Get(key []byte, readOptions ReadOptions) ([]byte, error) {	831✔
375	_, ss := f.SegmentStack()	831✔
376	if ss == nil {	831✔
377	f.DecRef()	×
378	return nil, nil	×
379	}	×
380
381	rv, err := ss.Get(key, readOptions)	831✔
382	if err == nil && rv != nil && !readOptions.NoCopyValue {	989✔
383	rv = append(make([]byte, 0, len(rv)), rv...) // Copy.	158✔
384	}	158✔
385
386	f.DecRef()	831✔
387		831✔
388	return rv, err	831✔
389	}
390
391	// StartIterator returns a new Iterator instance on this footer.
392	//
393	// On success, the returned Iterator will be positioned so that
394	// Iterator.Current() will either provide the first entry in the
395	// range or ErrIteratorDone.
396	//
397	// A startKeyIncl of nil means the logical "bottom-most" possible key
398	// and an endKeyExcl of nil means the logical "top-most" possible key.
399	func (f *Footer) StartIterator(startKeyIncl, endKeyExcl []byte,
400	iteratorOptions IteratorOptions) (Iterator, error) {	221✔
401	_, ss := f.SegmentStack()	221✔
402	if ss == nil {	221✔
403	f.DecRef()	×
404	return nil, nil	×
405	}	×
406
407	iter, err := ss.StartIterator(startKeyIncl, endKeyExcl, iteratorOptions)	221✔
408	if err != nil \|\| iter == nil {	221✔
409	f.DecRef()	×
410	return nil, err	×
411	}	×
412
413	initCloser, ok := iter.(InitCloser)	221✔
414	if !ok \|\| initCloser == nil {	221✔
415	iter.Close()	×
416	f.DecRef()	×
417	return nil, ErrUnexpected	×
418	}	×
419
420	err = initCloser.InitCloser(f)	221✔
421	if err != nil {	221✔
422	iter.Close()	×
423	f.DecRef()	×
424	return nil, err	×
425	}	×
426
427	return iter, nil	221✔
428	}

couchbase / moss / 174

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous