couchbase / moss / 195

pending completion

Build # 195

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/800e13ebc7a851f833367f7f3caf3d10ec89b405">800e13ebc<a href="https://github.com/couchbase/moss/commit/800e13ebc7a851f833367f7f3caf3d10ec89b405">&quot;&gt;simplify SegmentLoaderFunc contract

move the assumption that the kvs section is just a slice
of uint64 into the loadBasicSegment implementation

this allows future implementations to do something different
with the underlying bytes

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/23df1102556abedbc9aad852aa30e57f50087c41">23df11025</a>">23df11025</a><a href="https://github.com/couchbase/moss/commit/800e13ebc7a851f833367f7f3caf3d10ec89b405">
Reviewed-on: http://review.couchbase.org/74599
Tested-by: Marty Schoch <marty.schoch@gmail.com>
Reviewed-by: Steve Yen <steve.yen@gmail.com>

Run Details

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

3170 of 4002 relevant lines covered (79.21%)

10236.69 hits per line

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

71.57

/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 := 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
                                }

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

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

couchbase / moss / 195

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