couchbase / moss / 220

pending completion

Build # 220

Build Type

push

travis-ci

Committed by

mschoch

Commit Message

<a href="https://github.com/couchbase/moss/commit/<a class=hub.com/couchbase/moss/commit/0fc17b17918197afa97b2facc7fca1f5f12e930a">0fc17b179<a href="https://github.com/couchbase/moss/commit/0fc17b17918197afa97b2facc7fca1f5f12e930a">&quot;&gt;fix issues identified by the lint tool

Change-Id: I</a><a class="double-link" href="https://github.com/couchbase/moss/commit/<a class="double-link" href="https://github.com/couchbase/moss/commit/1a620f8254209d2c3ec0388dcce9e263c5739c33">1a620f825</a>">1a620f825</a><a href="https://github.com/couchbase/moss/commit/0fc17b17918197afa97b2facc7fca1f5f12e930a">
Reviewed-on: http://review.couchbase.org/75838
Tested-by: Build Bot <build@couchbase.com>
Reviewed-by: Steve Yen <steve.yen@gmail.com>

Run Details

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

2835 of 3446 relevant lines covered (82.27%)

12332.47 hits per line

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

71.2

/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)
}

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

// 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	"time"
20
21	"github.com/edsrzf/mmap-go"
22	)
23
24	func (s Store) persistFooter(file File, footer Footer,
25	options StorePersistOptions) error {	118✔
26	startTime := time.Now()	118✔
27	if !options.NoSync {	235✔
28	err := file.Sync()	117✔
29	if err != nil {	117✔
30	return err	×
31	}	×
32	}
33
34	err := s.persistFooterUnsynced(file, footer)	118✔
35	if err != nil {	118✔
36	return err	×
37	}	×
38
39	if !options.NoSync {	235✔
40	err = file.Sync()	117✔
41	}	117✔
42
43	if err == nil {	236✔
44	s.histograms["PersistFooterUsecs"].Add(	118✔
45	uint64(time.Since(startTime).Nanoseconds()/1000), 1)	118✔
46	}	118✔
47
48	return err	118✔
49	}
50
51	func (s Store) persistFooterUnsynced(file File, footer Footer) error {	118✔
52	jBuf, err := json.Marshal(footer)	118✔
53	if err != nil {	118✔
54	return err	×
55	}	×
56
57	finfo, err := file.Stat()	118✔
58	if err != nil {	118✔
59	return err	×
60	}	×
61
62	footerPos := pageAlignCeil(finfo.Size())	118✔
63	footerLen := footerBegLen + len(jBuf) + footerEndLen	118✔
64		118✔
65	footerBuf := bytes.NewBuffer(make([]byte, 0, footerLen))	118✔
66	footerBuf.Write(StoreMagicBeg)	118✔
67	footerBuf.Write(StoreMagicBeg)	118✔
68	binary.Write(footerBuf, StoreEndian, uint32(StoreVersion))	118✔
69	binary.Write(footerBuf, StoreEndian, uint32(footerLen))	118✔
70	footerBuf.Write(jBuf)	118✔
71	binary.Write(footerBuf, StoreEndian, footerPos)	118✔
72	binary.Write(footerBuf, StoreEndian, uint32(footerLen))	118✔
73	footerBuf.Write(StoreMagicEnd)	118✔
74	footerBuf.Write(StoreMagicEnd)	118✔
75		118✔
76	footerWritten, err := file.WriteAt(footerBuf.Bytes(), footerPos)	118✔
77	if err != nil {	118✔
78	return err	×
79	}	×
80	if footerWritten != len(footerBuf.Bytes()) {	118✔
81	return fmt.Errorf("store: persistFooter error writing all footerBuf")	×
82	}	×
83
84	footer.fileName = finfo.Name()	118✔
85	footer.filePos = footerPos	118✔
86		118✔
87	return nil	118✔
88	}
89
90	// --------------------------------------------------------
91
92	// ReadFooter reads the last valid Footer from a file.
93	func ReadFooter(options StoreOptions, file File) (Footer, error) {	92✔
94	finfo, err := file.Stat()	92✔
95	if err != nil {	92✔
96	return nil, err	×
97	}	×
98
99	fref := &FileRef{file: file, refs: 1}	92✔
100		92✔
101	f, err := ScanFooter(options, fref, finfo.Name(), finfo.Size())	92✔
102	if err != nil {	96✔
103	return nil, err	4✔
104	}	4✔
105
106	fref.DecRef() // ScanFooter added its own ref-counts on success.	88✔
107		88✔
108	return f, err	88✔
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) {	95✔
117	footerBeg := make([]byte, footerBegLen)	95✔
118		95✔
119	// Align pos to the start of a page (floor).	95✔
120	pos = pageAlignFloor(pos)	95✔
121		95✔
122	for {	190✔
123	for { // Scan the page for StoreMagicBeg, which might be a potential footer.	196✔
124	if pos <= 0 {	102✔
125	return nil, ErrNoValidFooter	1✔
126	}	1✔
127	n, err := fref.file.ReadAt(footerBeg, pos)	100✔
128	if err != nil {	104✔
129	return nil, err	4✔
130	}	4✔
131
132	if n == footerBegLen &&	96✔
133	bytes.Equal(StoreMagicBeg, footerBeg[:lenMagicBeg]) &&	96✔
134	bytes.Equal(StoreMagicBeg, footerBeg[lenMagicBeg:2*lenMagicBeg]) {	186✔
135	break	90✔
136	} // Else, file pos out of bounds likely.
137
138	// Move pos back by page size.
139	pos -= int64(StorePageSize)	6✔
140	}
141
142	// Read and check the potential footer.
143	footerBegBuf := bytes.NewBuffer(footerBeg[2*lenMagicBeg:])	90✔
144		90✔
145	var version uint32	90✔
146	if err := binary.Read(footerBegBuf, StoreEndian, &version); err != nil {	90✔
147	return nil, err	×
148	}	×
149	if version != StoreVersion {	90✔
150	return nil, fmt.Errorf("store: version mismatch, "+	×
151	"current: %v != found: %v", StoreVersion, version)	×
152	}	×
153
154	var length uint32	90✔
155	if err := binary.Read(footerBegBuf, StoreEndian, &length); err != nil {	90✔
156	return nil, err	×
157	}	×
158
159	data := make([]byte, int64(length)-int64(footerBegLen))	90✔
160		90✔
161	n, err := fref.file.ReadAt(data, pos+int64(footerBegLen))	90✔
162	if err != nil {	90✔
163	return nil, err	×
164	}	×
165
166	if n == len(data) &&	90✔
167	bytes.Equal(StoreMagicEnd, data[n-lenMagicEnd*2:n-lenMagicEnd]) &&	90✔
168	bytes.Equal(StoreMagicEnd, data[n-lenMagicEnd:]) {	180✔
169		90✔
170	content := int(length) - footerBegLen - footerEndLen	90✔
171	b := bytes.NewBuffer(data[content:])	90✔
172		90✔
173	var offset int64	90✔
174	if err := binary.Read(b, StoreEndian, &offset); err != nil {	90✔
175	return nil, err	×
176	}	×
177	if offset != pos {	90✔
178	return nil, fmt.Errorf("store: offset mismatch, "+	×
179	"wanted: %v != found: %v", offset, pos)	×
180	}	×
181
182	var length1 uint32	90✔
183	if err := binary.Read(b, StoreEndian, &length1); err != nil {	90✔
184	return nil, err	×
185	}	×
186	if length1 != length {	90✔
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}	90✔
192		90✔
193	err = json.Unmarshal(data[:content], f)	90✔
194	if err != nil {	90✔
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)	90✔
202	if err != nil {	90✔
203	return nil, err	×
204	}	×
205
206	return f, nil	90✔
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) {	133✔
222	// Track mrefs that we need to DecRef() if there's an error.	133✔
223	mrefs := make([]*mmapRef, 0, len(f.SegmentLocs))	133✔
224	mrefs, err = f.doLoadSegments(options, fref, mrefs)	133✔
225	if err != nil {	133✔
226	for _, mref := range mrefs {	×
227	mref.DecRef()	×
228	}	×
229	return err	×
230	}
231
232	return err	133✔
233	}
234
235	func (f Footer) doLoadSegments(options StoreOptions, fref *FileRef,
236	mrefs []mmapRef) (mrefsSoFar []mmapRef, err error) {	168✔
237	// Recursively load the childFooters first.	168✔
238	for _, childFooter := range f.ChildFooters {	203✔
239	mrefs, err = childFooter.doLoadSegments(options, fref, mrefs)	35✔
240	if err != nil {	35✔
241	return mrefs, err	×
242	}	×
243	}
244
245	if f.ss != nil && f.ss.a != nil {	168✔
246	return mrefs, nil	×
247	}	×
248
249	osFile := ToOsFile(fref.file)	168✔
250	if osFile == nil {	168✔
251	return mrefs, fmt.Errorf("store: loadSegments convert to os.File error")	×
252	}	×
253
254	a := make([]Segment, len(f.SegmentLocs))	168✔
255		168✔
256	for i := range f.SegmentLocs {	468✔
257	sloc := &f.SegmentLocs[i]	300✔
258		300✔
259	mref := sloc.mref	300✔
260	if mref != nil {	426✔
261	if mref.fref != fref {	126✔
262	return mrefs, fmt.Errorf("store: loadSegments fref mismatch")	×
263	}	×
264
265	mref.AddRef()	126✔
266	} else {	174✔
267	// We persist kvs before buf, so KvsOffset < BufOffset.	174✔
268	begOffset := int64(sloc.KvsOffset)	174✔
269	endOffset := int64(sloc.BufOffset + sloc.BufBytes)	174✔
270		174✔
271	nbytes := int(endOffset - begOffset)	174✔
272		174✔
273	// Some platforms (windows) only support mmap()'ing at an	174✔
274	// allocation granularity that's != to a page size, so	174✔
275	// calculate the actual offset/nbytes to use.	174✔
276	begOffsetActual := pageOffset(begOffset, int64(AllocationGranularity))	174✔
277	begOffsetDelta := int(begOffset - begOffsetActual)	174✔
278	nbytesActual := nbytes + begOffsetDelta	174✔
279		174✔
280	mm, err := mmap.MapRegion(osFile, nbytesActual, mmap.RDONLY, 0, begOffsetActual)	174✔
281	if err != nil {	174✔
282	return mrefs, fmt.Errorf("store: loadSegments mmap.Map(), err: %v", err)	×
283	}	×
284
285	fref.AddRef() // New mref owns 1 fref ref-count.	174✔
286		174✔
287	buf := mm[begOffsetDelta : begOffsetDelta+nbytes]	174✔
288		174✔
289	sloc.mref = &mmapRef{fref: fref, mm: mm, buf: buf, refs: 1}	174✔
290		174✔
291	mref = sloc.mref	174✔
292	}
293
294	mrefs = append(mrefs, mref)	300✔
295		300✔
296	segmentLoader, exists := SegmentLoaders[sloc.Kind]	300✔
297	if !exists \|\| segmentLoader == nil {	300✔
298	return mrefs, fmt.Errorf("store: unknown SegmentLoc kind, sloc: %+v", sloc)	×
299	}	×
300
301	seg, err := segmentLoader(sloc)	300✔
302	if err != nil {	300✔
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	300✔
308	}
309
310	f.ss = &segmentStack{	168✔
311	options: &options.CollectionOptions,	168✔
312	a: a,	168✔
313	refs: 1,	168✔
314	}	168✔
315		168✔
316	return mrefs, nil	168✔
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) {	317✔
336	childFooter, exists := f.ChildFooters[childCollectionName]	317✔
337	if !exists {	351✔
338	return nil, nil	34✔
339	}	34✔
340	childFooter.AddRef()	283✔
341	return childFooter, nil	283✔
342	}
343
344	// Close decrements the ref count on this footer
345	func (f *Footer) Close() error {	418✔
346	f.DecRef()	418✔
347	return nil	418✔
348	}	418✔
349
350	// AddRef increases the ref count on this footer
351	func (f *Footer) AddRef() {	529✔
352	f.m.Lock()	529✔
353	f.refs++	529✔
354	f.m.Unlock()	529✔
355	}	529✔
356
357	// DecRef decreases the ref count on this footer
358	func (f *Footer) DecRef() {	1,721✔
359	f.m.Lock()	1,721✔
360	f.refs--	1,721✔
361	if f.refs <= 0 {	1,877✔
362	f.SegmentLocs.DecRef()	156✔
363	f.SegmentLocs = nil	156✔
364	f.ss = nil	156✔
365	}	156✔
366	f.m.Unlock()	1,721✔
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	// SegmentStack 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) SegmentStack() (SegmentLocs, segmentStack) {	1,322✔
386	f.m.Lock()	1,322✔
387		1,322✔
388	f.refs++	1,322✔
389		1,322✔
390	slocs, ss := f.SegmentLocs, f.ss	1,322✔
391		1,322✔
392	f.m.Unlock()	1,322✔
393		1,322✔
394	return slocs, ss	1,322✔
395	}	1,322✔
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) {	895✔
402	_, ss := f.SegmentStack()	895✔
403	if ss == nil {	895✔
404	f.DecRef()	×
405	return nil, nil	×
406	}	×
407
408	rv, err := ss.Get(key, readOptions)	895✔
409	if err == nil && rv != nil && !readOptions.NoCopyValue {	1,117✔
410	rv = append(make([]byte, 0, len(rv)), rv...) // Copy.	222✔
411	}	222✔
412
413	f.DecRef()	895✔
414		895✔
415	return rv, err	895✔
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.SegmentStack()	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 / 220

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