couchbase / moss / 241

pending completion

Build # 241

Build Type

push

travis-ci

Committed by

hisundar

Commit Message

Optimization to jump to previous footer via its offset

This prevents snapshotPrevious from scanning the file
byte-by-byte to reach the previous footer and instead
just jump to it by its offset.

Change-Id: I769fb1f55
Reviewed-on: http://review.couchbase.org/77473
Well-Formed: Build Bot <build@couchbase.com>
Reviewed-by: Steve Yen <steve.yen@gmail.com>
Tested-by: Sundararaman Sridharan <sundar@couchbase.com>

Run Details

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

2948 of 3549 relevant lines covered (83.07%)

35511.14 hits per line

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

70.87

/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"
        "time"

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

func (s *Store) persistFooter(file File, footer *Footer,
        options StorePersistOptions) error {
        startTime := time.Now()
        if !options.NoSync {
                err := file.Sync()
                if err != nil {
                        return err
                }
        }

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

        if !options.NoSync {
                err = file.Sync()
        }

        if err == nil {
                s.histograms["PersistFooterUsecs"].Add(
                        uint64(time.Since(startTime).Nanoseconds()/1000), 1)
        }

        return err
}

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 := pageAlignCeil(finfo.Size())
        footerLen := footerBegLen + len(jBuf) + footerEndLen

        footerBuf := bytes.NewBuffer(make([]byte, 0, footerLen))
        footerBuf.Write(StoreMagicBeg)
        footerBuf.Write(StoreMagicBeg)
        binary.Write(footerBuf, StoreEndian, uint32(StoreVersion))
        binary.Write(footerBuf, StoreEndian, uint32(footerLen))
        footerBuf.Write(jBuf)
        binary.Write(footerBuf, StoreEndian, footerPos)
        binary.Write(footerBuf, StoreEndian, uint32(footerLen))
        footerBuf.Write(StoreMagicEnd)
        footerBuf.Write(StoreMagicEnd)

        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) {
        footerBeg := make([]byte, footerBegLen)

        // Align pos to the start of a page (floor).
        pos = pageAlignFloor(pos)

        for {
                for { // Scan the page for StoreMagicBeg, which might be a potential footer.
                        if pos <= 0 {
                                return nil, ErrNoValidFooter
                        }
                        n, err := fref.file.ReadAt(footerBeg, pos)
                        if err != nil {
                                return nil, err
                        }

                        if n == footerBegLen &&
                                bytes.Equal(StoreMagicBeg, footerBeg[:lenMagicBeg]) &&
                                bytes.Equal(StoreMagicBeg, footerBeg[lenMagicBeg:2*lenMagicBeg]) {
                                break
                        } // Else, file pos out of bounds likely.

                        // Move pos back by page size.
                        pos -= int64(StorePageSize)
                }

                // Read and check the potential footer.
                footerBegBuf := bytes.NewBuffer(footerBeg[2*lenMagicBeg:])

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

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

                data := make([]byte, int64(length)-int64(footerBegLen))

                n, err := fref.file.ReadAt(data, pos+int64(footerBegLen))
                if err != nil {
                        return nil, err
                }

                if n == len(data) &&
                        bytes.Equal(StoreMagicEnd, data[n-lenMagicEnd*2:n-lenMagicEnd]) &&
                        bytes.Equal(StoreMagicEnd, data[n-lenMagicEnd:]) {

                        content := int(length) - footerBegLen - footerEndLen
                        b := bytes.NewBuffer(data[content:])

                        var offset int64
                        if err = binary.Read(b, StoreEndian, &offset); err != nil {
                                return nil, err
                        }
                        if offset != pos {
                                return nil, fmt.Errorf("store: offset mismatch, "+
                                        "wanted: %v != found: %v", offset, pos)
                        }

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

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

                        err = json.Unmarshal(data[:content], f)
                        if err != nil {
                                return nil, err
                        }

                        // json.Unmarshal would have just loaded the map.
                        // We now need to load the segments into the map.
                        // Recursively load the Child Footer segment stacks.
                        err = f.loadSegments(options, fref)
                        if err != nil {
                                return nil, err
                        }

                        return f, nil
                }
                // Else, invalid footer - StoreMagicEnd missing and/or file
                // pos out of bounds.

                // Footer was invalid, so keep scanning.
                pos -= int64(StorePageSize)
        }
}

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

// 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) {
        // Track mrefs that we need to DecRef() if there's an error.
        mrefs := make([]*mmapRef, 0, len(f.SegmentLocs))
        mrefs, err = f.doLoadSegments(options, fref, mrefs)
        if err != nil {
                for _, mref := range mrefs {
                        mref.DecRef()
                }
                return err
        }

        return err
}

func (f *Footer) doLoadSegments(options *StoreOptions, fref *FileRef,
        mrefs []*mmapRef) (mrefsSoFar []*mmapRef, err error) {
        // Recursively load the childFooters first.
        for _, childFooter := range f.ChildFooters {
                mrefs, err = childFooter.doLoadSegments(options, fref, mrefs)
                if err != nil {
                        return mrefs, err
                }
        }

        if f.ss != nil && f.ss.a != nil {
                return mrefs, nil
        }

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

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

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

                mref := sloc.mref
                if mref != nil {
                        if mref.fref != fref {
                                return mrefs, 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 {
                                return mrefs, 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 {
                        return mrefs, fmt.Errorf("store: unknown SegmentLoc kind, sloc: %+v", sloc)
                }

                seg, err := segmentLoader(sloc)
                if err != nil {
                        return mrefs, fmt.Errorf("store: segmentLoader failed, footer: %+v,"+
                                " f.SegmentLocs: %+v, i: %d, options: %v err: %+v", f, f.SegmentLocs, i, options, err)
                }

                a[i] = seg
        }

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

        return mrefs, nil
}

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

// ChildCollectionNames returns an array of child collection name strings.
func (f *Footer) ChildCollectionNames() ([]string, error) {
        var childNames = make([]string, len(f.ChildFooters))
        idx := 0
        for name := range f.ChildFooters {
                childNames[idx] = name
                idx++
        }
        return childNames, nil
}

// ChildCollectionSnapshot returns a Snapshot on a given child
// collection by its name.
func (f *Footer) ChildCollectionSnapshot(childCollectionName string) (
        Snapshot, error) {
        childFooter, exists := f.ChildFooters[childCollectionName]
        if !exists {
                return nil, nil
        }
        childFooter.AddRef()
        return childFooter, nil
}

// Close decrements the ref count on this footer
func (f *Footer) Close() error {
        f.DecRef()
        return nil
}

// AddRef increases the ref count on this footer
func (f *Footer) AddRef() {
        f.m.Lock()
        f.refs++
        f.m.Unlock()
}

// DecRef decreases the ref count on this footer
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()
}

// Length returns the length of this footer
func (f *Footer) Length() uint64 {
        jBuf, err := json.Marshal(f)
        if err != nil {
                return 0
        }

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

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

// segmentLocs 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) segmentLocs() (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.segmentLocs()
        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.segmentLocs()
        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	"time"
20
21	"github.com/edsrzf/mmap-go"
22	)
23
24	func (s Store) persistFooter(file File, footer Footer,
25	options StorePersistOptions) error {	140✔
26	startTime := time.Now()	140✔
27	if !options.NoSync {	279✔
28	err := file.Sync()	139✔
29	if err != nil {	139✔
30	return err	×
31	}	×
32	}
33
34	err := s.persistFooterUnsynced(file, footer)	140✔
35	if err != nil {	140✔
36	return err	×
37	}	×
38
39	if !options.NoSync {	279✔
40	err = file.Sync()	139✔
41	}	139✔
42
43	if err == nil {	280✔
44	s.histograms["PersistFooterUsecs"].Add(	140✔
45	uint64(time.Since(startTime).Nanoseconds()/1000), 1)	140✔
46	}	140✔
47
48	return err	140✔
49	}
50
51	func (s Store) persistFooterUnsynced(file File, footer Footer) error {	140✔
52	jBuf, err := json.Marshal(footer)	140✔
53	if err != nil {	140✔
54	return err	×
55	}	×
56
57	finfo, err := file.Stat()	140✔
58	if err != nil {	140✔
59	return err	×
60	}	×
61
62	footerPos := pageAlignCeil(finfo.Size())	140✔
63	footerLen := footerBegLen + len(jBuf) + footerEndLen	140✔
64		140✔
65	footerBuf := bytes.NewBuffer(make([]byte, 0, footerLen))	140✔
66	footerBuf.Write(StoreMagicBeg)	140✔
67	footerBuf.Write(StoreMagicBeg)	140✔
68	binary.Write(footerBuf, StoreEndian, uint32(StoreVersion))	140✔
69	binary.Write(footerBuf, StoreEndian, uint32(footerLen))	140✔
70	footerBuf.Write(jBuf)	140✔
71	binary.Write(footerBuf, StoreEndian, footerPos)	140✔
72	binary.Write(footerBuf, StoreEndian, uint32(footerLen))	140✔
73	footerBuf.Write(StoreMagicEnd)	140✔
74	footerBuf.Write(StoreMagicEnd)	140✔
75		140✔
76	footerWritten, err := file.WriteAt(footerBuf.Bytes(), footerPos)	140✔
77	if err != nil {	140✔
78	return err	×
79	}	×
80	if footerWritten != len(footerBuf.Bytes()) {	140✔
81	return fmt.Errorf("store: persistFooter error writing all footerBuf")	×
82	}	×
83
84	footer.fileName = finfo.Name()	140✔
85	footer.filePos = footerPos	140✔
86		140✔
87	return nil	140✔
88	}
89
90	// --------------------------------------------------------
91
92	// ReadFooter reads the last valid Footer from a file.
93	func ReadFooter(options StoreOptions, file File) (Footer, error) {	100✔
94	finfo, err := file.Stat()	100✔
95	if err != nil {	100✔
96	return nil, err	×
97	}	×
98
99	fref := &FileRef{file: file, refs: 1}	100✔
100		100✔
101	f, err := ScanFooter(options, fref, finfo.Name(), finfo.Size())	100✔
102	if err != nil {	104✔
103	return nil, err	4✔
104	}	4✔
105
106	fref.DecRef() // ScanFooter added its own ref-counts on success.	96✔
107		96✔
108	return f, err	96✔
109	}
110
111	// --------------------------------------------------------
112
113	// ScanFooter scans a file backwards from the given pos for a valid
114	// Footer, adding ref-counts to fref on success.
115	func ScanFooter(options StoreOptions, fref FileRef, fileName string,
116	pos int64) (*Footer, error) {	103✔
117	footerBeg := make([]byte, footerBegLen)	103✔
118		103✔
119	// Align pos to the start of a page (floor).	103✔
120	pos = pageAlignFloor(pos)	103✔
121		103✔
122	for {	206✔
123	for { // Scan the page for StoreMagicBeg, which might be a potential footer.	206✔
124	if pos <= 0 {	104✔
125	return nil, ErrNoValidFooter	1✔
126	}	1✔
127	n, err := fref.file.ReadAt(footerBeg, pos)	102✔
128	if err != nil {	106✔
129	return nil, err	4✔
130	}	4✔
131
132	if n == footerBegLen &&	98✔
133	bytes.Equal(StoreMagicBeg, footerBeg[:lenMagicBeg]) &&	98✔
134	bytes.Equal(StoreMagicBeg, footerBeg[lenMagicBeg:2*lenMagicBeg]) {	196✔
135	break	98✔
136	} // Else, file pos out of bounds likely.
137
138	// Move pos back by page size.
139	pos -= int64(StorePageSize)	×
140	}
141
142	// Read and check the potential footer.
143	footerBegBuf := bytes.NewBuffer(footerBeg[2*lenMagicBeg:])	98✔
144		98✔
145	var version uint32	98✔
146	if err := binary.Read(footerBegBuf, StoreEndian, &version); err != nil {	98✔
147	return nil, err	×
148	}	×
149	if version != StoreVersion {	98✔
150	return nil, fmt.Errorf("store: version mismatch, "+	×
151	"current: %v != found: %v", StoreVersion, version)	×
152	}	×
153
154	var length uint32	98✔
155	if err := binary.Read(footerBegBuf, StoreEndian, &length); err != nil {	98✔
156	return nil, err	×
157	}	×
158
159	data := make([]byte, int64(length)-int64(footerBegLen))	98✔
160		98✔
161	n, err := fref.file.ReadAt(data, pos+int64(footerBegLen))	98✔
162	if err != nil {	98✔
163	return nil, err	×
164	}	×
165
166	if n == len(data) &&	98✔
167	bytes.Equal(StoreMagicEnd, data[n-lenMagicEnd*2:n-lenMagicEnd]) &&	98✔
168	bytes.Equal(StoreMagicEnd, data[n-lenMagicEnd:]) {	196✔
169		98✔
170	content := int(length) - footerBegLen - footerEndLen	98✔
171	b := bytes.NewBuffer(data[content:])	98✔
172		98✔
173	var offset int64	98✔
174	if err = binary.Read(b, StoreEndian, &offset); err != nil {	98✔
175	return nil, err	×
176	}	×
177	if offset != pos {	98✔
178	return nil, fmt.Errorf("store: offset mismatch, "+	×
179	"wanted: %v != found: %v", offset, pos)	×
180	}	×
181
182	var length1 uint32	98✔
183	if err = binary.Read(b, StoreEndian, &length1); err != nil {	98✔
184	return nil, err	×
185	}	×
186	if length1 != length {	98✔
187	return nil, fmt.Errorf("store: length mismatch, "+	×
188	"wanted: %v != found: %v", length1, length)	×
189	}	×
190
191	f := &Footer{refs: 1, fileName: fileName, filePos: offset}	98✔
192		98✔
193	err = json.Unmarshal(data[:content], f)	98✔
194	if err != nil {	98✔
195	return nil, err	×
196	}	×
197
198	// json.Unmarshal would have just loaded the map.
199	// We now need to load the segments into the map.
200	// Recursively load the Child Footer segment stacks.
201	err = f.loadSegments(options, fref)	98✔
202	if err != nil {	98✔
203	return nil, err	×
204	}	×
205
206	return f, nil	98✔
207	}
208	// Else, invalid footer - StoreMagicEnd missing and/or file
209	// pos out of bounds.
210
211	// Footer was invalid, so keep scanning.
212	pos -= int64(StorePageSize)	×
213	}
214	}
215
216	// --------------------------------------------------------
217
218	// loadSegments() loads the segments of a footer, which must not be
219	// already loaded. The footer adds new ref-counts to the fref on
220	// success. The footer will be in an already closed state on error.
221	func (f Footer) loadSegments(options StoreOptions, fref *FileRef) (err error) {	155✔
222	// Track mrefs that we need to DecRef() if there's an error.	155✔
223	mrefs := make([]*mmapRef, 0, len(f.SegmentLocs))	155✔
224	mrefs, err = f.doLoadSegments(options, fref, mrefs)	155✔
225	if err != nil {	155✔
226	for _, mref := range mrefs {	×
227	mref.DecRef()	×
228	}	×
229	return err	×
230	}
231
232	return err	155✔
233	}
234
235	func (f Footer) doLoadSegments(options StoreOptions, fref *FileRef,
236	mrefs []mmapRef) (mrefsSoFar []mmapRef, err error) {	194✔
237	// Recursively load the childFooters first.	194✔
238	for _, childFooter := range f.ChildFooters {	233✔
239	mrefs, err = childFooter.doLoadSegments(options, fref, mrefs)	39✔
240	if err != nil {	39✔
241	return mrefs, err	×
242	}	×
243	}
244
245	if f.ss != nil && f.ss.a != nil {	194✔
246	return mrefs, nil	×
247	}	×
248
249	osFile := ToOsFile(fref.file)	194✔
250	if osFile == nil {	194✔
251	return mrefs, fmt.Errorf("store: loadSegments convert to os.File error")	×
252	}	×
253
254	a := make([]Segment, len(f.SegmentLocs))	194✔
255		194✔
256	for i := range f.SegmentLocs {	687✔
257	sloc := &f.SegmentLocs[i]	493✔
258		493✔
259	mref := sloc.mref	493✔
260	if mref != nil {	789✔
261	if mref.fref != fref {	296✔
262	return mrefs, fmt.Errorf("store: loadSegments fref mismatch")	×
263	}	×
264
265	mref.AddRef()	296✔
266	} else {	197✔
267	// We persist kvs before buf, so KvsOffset < BufOffset.	197✔
268	begOffset := int64(sloc.KvsOffset)	197✔
269	endOffset := int64(sloc.BufOffset + sloc.BufBytes)	197✔
270		197✔
271	nbytes := int(endOffset - begOffset)	197✔
272		197✔
273	// Some platforms (windows) only support mmap()'ing at an	197✔
274	// allocation granularity that's != to a page size, so	197✔
275	// calculate the actual offset/nbytes to use.	197✔
276	begOffsetActual := pageOffset(begOffset, int64(AllocationGranularity))	197✔
277	begOffsetDelta := int(begOffset - begOffsetActual)	197✔
278	nbytesActual := nbytes + begOffsetDelta	197✔
279		197✔
280	mm, err := mmap.MapRegion(osFile, nbytesActual, mmap.RDONLY, 0, begOffsetActual)	197✔
281	if err != nil {	197✔
282	return mrefs, fmt.Errorf("store: loadSegments mmap.Map(), err: %v", err)	×
283	}	×
284
285	fref.AddRef() // New mref owns 1 fref ref-count.	197✔
286		197✔
287	buf := mm[begOffsetDelta : begOffsetDelta+nbytes]	197✔
288		197✔
289	sloc.mref = &mmapRef{fref: fref, mm: mm, buf: buf, refs: 1}	197✔
290		197✔
291	mref = sloc.mref	197✔
292	}
293
294	mrefs = append(mrefs, mref)	493✔
295		493✔
296	segmentLoader, exists := SegmentLoaders[sloc.Kind]	493✔
297	if !exists \|\| segmentLoader == nil {	493✔
298	return mrefs, fmt.Errorf("store: unknown SegmentLoc kind, sloc: %+v", sloc)	×
299	}	×
300
301	seg, err := segmentLoader(sloc)	493✔
302	if err != nil {	493✔
303	return mrefs, fmt.Errorf("store: segmentLoader failed, footer: %+v,"+	×
304	" f.SegmentLocs: %+v, i: %d, options: %v err: %+v", f, f.SegmentLocs, i, options, err)	×
305	}	×
306
307	a[i] = seg	493✔
308	}
309
310	f.ss = &segmentStack{	194✔
311	options: &options.CollectionOptions,	194✔
312	a: a,	194✔
313	refs: 1,	194✔
314	}	194✔
315		194✔
316	return mrefs, nil	194✔
317	}
318
319	// --------------------------------------------------------
320
321	// ChildCollectionNames returns an array of child collection name strings.
322	func (f *Footer) ChildCollectionNames() ([]string, error) {	×
323	var childNames = make([]string, len(f.ChildFooters))	×
324	idx := 0	×
325	for name := range f.ChildFooters {	×
326	childNames[idx] = name	×
327	idx++	×
328	}	×
329	return childNames, nil	×
330	}
331
332	// ChildCollectionSnapshot returns a Snapshot on a given child
333	// collection by its name.
334	func (f *Footer) ChildCollectionSnapshot(childCollectionName string) (
335	Snapshot, error) {	315✔
336	childFooter, exists := f.ChildFooters[childCollectionName]	315✔
337	if !exists {	373✔
338	return nil, nil	58✔
339	}	58✔
340	childFooter.AddRef()	257✔
341	return childFooter, nil	257✔
342	}
343
344	// Close decrements the ref count on this footer
345	func (f *Footer) Close() error {	438✔
346	f.DecRef()	438✔
347	return nil	438✔
348	}	438✔
349
350	// AddRef increases the ref count on this footer
351	func (f *Footer) AddRef() {	535✔
352	f.m.Lock()	535✔
353	f.refs++	535✔
354	f.m.Unlock()	535✔
355	}	535✔
356
357	// DecRef decreases the ref count on this footer
358	func (f *Footer) DecRef() {	3,393✔
359	f.m.Lock()	3,393✔
360	f.refs--	3,393✔
361	if f.refs <= 0 {	3,568✔
362	f.SegmentLocs.DecRef()	175✔
363	f.SegmentLocs = nil	175✔
364	f.ss = nil	175✔
365	}	175✔
366	f.m.Unlock()	3,393✔
367	}
368
369	// Length returns the length of this footer
370	func (f *Footer) Length() uint64 {	×
371	jBuf, err := json.Marshal(f)	×
372	if err != nil {	×
373	return 0	×
374	}	×
375
376	footerLen := footerBegLen + len(jBuf) + footerEndLen	×
377	return uint64(footerLen)	×
378	}
379
380	// --------------------------------------------------------
381
382	// segmentLocs returns the current SegmentLocs and segmentStack for
383	// a footer, while also incrementing the ref-count on the footer. The
384	// caller must DecRef() the footer when done.
385	func (f Footer) segmentLocs() (SegmentLocs, segmentStack) {	2,946✔
386	f.m.Lock()	2,946✔
387		2,946✔
388	f.refs++	2,946✔
389		2,946✔
390	slocs, ss := f.SegmentLocs, f.ss	2,946✔
391		2,946✔
392	f.m.Unlock()	2,946✔
393		2,946✔
394	return slocs, ss	2,946✔
395	}	2,946✔
396
397	// --------------------------------------------------------
398
399	// Get retrieves a val from the footer, and will return nil val
400	// if the entry does not exist in the footer.
401	func (f *Footer) Get(key []byte, readOptions ReadOptions) ([]byte, error) {	2,488✔
402	_, ss := f.segmentLocs()	2,488✔
403	if ss == nil {	2,488✔
404	f.DecRef()	×
405	return nil, nil	×
406	}	×
407
408	rv, err := ss.Get(key, readOptions)	2,488✔
409	if err == nil && rv != nil && !readOptions.NoCopyValue {	4,303✔
410	rv = append(make([]byte, 0, len(rv)), rv...) // Copy.	1,815✔
411	}	1,815✔
412
413	f.DecRef()	2,488✔
414		2,488✔
415	return rv, err	2,488✔
416	}
417
418	// StartIterator returns a new Iterator instance on this footer.
419	//
420	// On success, the returned Iterator will be positioned so that
421	// Iterator.Current() will either provide the first entry in the
422	// range or ErrIteratorDone.
423	//
424	// A startKeyIncl of nil means the logical "bottom-most" possible key
425	// and an endKeyExcl of nil means the logical "top-most" possible key.
426	func (f *Footer) StartIterator(startKeyIncl, endKeyExcl []byte,
427	iteratorOptions IteratorOptions) (Iterator, error) {	223✔
428	_, ss := f.segmentLocs()	223✔
429	if ss == nil {	223✔
430	f.DecRef()	×
431	return nil, nil	×
432	}	×
433
434	iter, err := ss.StartIterator(startKeyIncl, endKeyExcl, iteratorOptions)	223✔
435	if err != nil \|\| iter == nil {	223✔
436	f.DecRef()	×
437	return nil, err	×
438	}	×
439
440	initCloser, ok := iter.(InitCloser)	223✔
441	if !ok \|\| initCloser == nil {	223✔
442	iter.Close()	×
443	f.DecRef()	×
444	return nil, ErrUnexpected	×
445	}	×
446
447	err = initCloser.InitCloser(f)	223✔
448	if err != nil {	223✔
449	iter.Close()	×
450	f.DecRef()	×
451	return nil, err	×
452	}	×
453
454	return iter, nil	223✔
455	}

couchbase / moss / 241

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