couchbase / moss / 245

pending completion

Build # 245

Build Type

push

travis-ci

Committed by

steveyen

Commit Message

minor commentary / whitespace tweaks

Change-Id: I26d76f2d5
Reviewed-on: http://review.couchbase.org/77986
Well-Formed: Build Bot <build@couchbase.com>
Reviewed-by: Sreekanth Sivasankaran
Tested-by: Steve Yen <steve.yen@gmail.com>

Run Details

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

2952 of 3552 relevant lines covered (83.11%)

36985.71 hits per line

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

70.74

/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 for StoreMagicBeg, which may 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
                        }

                        // 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 each segment into the map.
                        // Also recursively load 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.  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 nil
}

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

couchbase / moss / 245

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