_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q36900 | Delete | train | func (db *DB) Delete(mint, maxt int64, ms ...labels.Matcher) error {
db.cmtx.Lock()
defer db.cmtx.Unlock()
var g errgroup.Group
db.mtx.RLock()
defer db.mtx.RUnlock()
for _, b := range db.blocks {
if b.OverlapsClosedInterval(mint, maxt) {
g.Go(func(b *Block) func() error {
return func() error { return ... | go | {
"resource": ""
} |
q36901 | CleanTombstones | train | func (db *DB) CleanTombstones() (err error) {
db.cmtx.Lock()
defer db.cmtx.Unlock()
start := time.Now()
defer db.metrics.tombCleanTimer.Observe(time.Since(start).Seconds())
newUIDs := []ulid.ULID{}
defer func() {
// If any error is caused, we need to delete all the new directory created.
if err != nil {
... | go | {
"resource": ""
} |
q36902 | ExponentialBlockRanges | train | func ExponentialBlockRanges(minSize int64, steps, stepSize int) []int64 {
ranges := make([]int64, 0, steps)
curRange := minSize
for i := 0; i < steps; i++ {
ranges = append(ranges, curRange)
curRange = curRange * int64(stepSize)
}
return ranges
} | go | {
"resource": ""
} |
q36903 | NewLeveledCompactor | train | func NewLeveledCompactor(ctx context.Context, r prometheus.Registerer, l log.Logger, ranges []int64, pool chunkenc.Pool) (*LeveledCompactor, error) {
if len(ranges) == 0 {
return nil, errors.Errorf("at least one range must be provided")
}
if pool == nil {
pool = chunkenc.NewPool()
}
if l == nil {
l = log.New... | go | {
"resource": ""
} |
q36904 | Plan | train | func (c *LeveledCompactor) Plan(dir string) ([]string, error) {
dirs, err := blockDirs(dir)
if err != nil {
return nil, err
}
if len(dirs) < 1 {
return nil, nil
}
var dms []dirMeta
for _, dir := range dirs {
meta, err := readMetaFile(dir)
if err != nil {
return nil, err
}
dms = append(dms, dirMet... | go | {
"resource": ""
} |
q36905 | selectDirs | train | func (c *LeveledCompactor) selectDirs(ds []dirMeta) []dirMeta {
if len(c.ranges) < 2 || len(ds) < 1 {
return nil
}
highTime := ds[len(ds)-1].meta.MinTime
for _, iv := range c.ranges[1:] {
parts := splitByRange(ds, iv)
if len(parts) == 0 {
continue
}
Outer:
for _, p := range parts {
// Do not sel... | go | {
"resource": ""
} |
q36906 | selectOverlappingDirs | train | func (c *LeveledCompactor) selectOverlappingDirs(ds []dirMeta) []string {
if len(ds) < 2 {
return nil
}
var overlappingDirs []string
globalMaxt := ds[0].meta.MaxTime
for i, d := range ds[1:] {
if d.meta.MinTime < globalMaxt {
if len(overlappingDirs) == 0 { // When it is the first overlap, need to add the la... | go | {
"resource": ""
} |
q36907 | addInterval | train | func (t *memTombstones) addInterval(ref uint64, itvs ...Interval) {
t.mtx.Lock()
defer t.mtx.Unlock()
for _, itv := range itvs {
t.intvlGroups[ref] = t.intvlGroups[ref].add(itv)
}
} | go | {
"resource": ""
} |
q36908 | add | train | func (itvs Intervals) add(n Interval) Intervals {
for i, r := range itvs {
// TODO(gouthamve): Make this codepath easier to digest.
if r.inBounds(n.Mint-1) || r.inBounds(n.Mint) {
if n.Maxt > r.Maxt {
itvs[i].Maxt = n.Maxt
}
j := 0
for _, r2 := range itvs[i+1:] {
if n.Maxt < r2.Mint {
bre... | go | {
"resource": ""
} |
q36909 | CopyDirs | train | func CopyDirs(src, dest string) error {
if err := os.MkdirAll(dest, 0777); err != nil {
return err
}
files, err := readDirs(src)
if err != nil {
return err
}
for _, f := range files {
dp := filepath.Join(dest, f)
sp := filepath.Join(src, f)
stat, err := os.Stat(sp)
if err != nil {
return err
}
... | go | {
"resource": ""
} |
q36910 | readDirs | train | func readDirs(src string) ([]string, error) {
var files []string
err := filepath.Walk(src, func(path string, f os.FileInfo, err error) error {
relativePath := strings.TrimPrefix(path, src)
if len(relativePath) > 0 {
files = append(files, relativePath)
}
return nil
})
if err != nil {
return nil, err
}... | go | {
"resource": ""
} |
q36911 | Replace | train | func Replace(from, to string) error {
if err := os.RemoveAll(to); err != nil {
return err
}
if err := os.Rename(from, to); err != nil {
return err
}
// Directory was renamed; sync parent dir to persist rename.
pdir, err := OpenDir(filepath.Dir(to))
if err != nil {
return err
}
if err = pdir.Sync(); err... | go | {
"resource": ""
} |
q36912 | LastCheckpoint | train | func LastCheckpoint(dir string) (string, int, error) {
files, err := ioutil.ReadDir(dir)
if err != nil {
return "", 0, err
}
// Traverse list backwards since there may be multiple checkpoints left.
for i := len(files) - 1; i >= 0; i-- {
fi := files[i]
if !strings.HasPrefix(fi.Name(), checkpointPrefix) {
... | go | {
"resource": ""
} |
q36913 | DeleteCheckpoints | train | func DeleteCheckpoints(dir string, maxIndex int) error {
var errs tsdb_errors.MultiError
files, err := ioutil.ReadDir(dir)
if err != nil {
return err
}
for _, fi := range files {
if !strings.HasPrefix(fi.Name(), checkpointPrefix) {
continue
}
index, err := strconv.Atoi(fi.Name()[len(checkpointPrefix):]... | go | {
"resource": ""
} |
q36914 | NewLiveReader | train | func NewLiveReader(logger log.Logger, r io.Reader) *LiveReader {
return &LiveReader{
logger: logger,
rdr: r,
// Until we understand how they come about, make readers permissive
// to records spanning pages.
permissive: true,
}
} | go | {
"resource": ""
} |
q36915 | Err | train | func (r *LiveReader) Err() error {
if r.eofNonErr && r.err == io.EOF {
return nil
}
return r.err
} | go | {
"resource": ""
} |
q36916 | buildRecord | train | func (r *LiveReader) buildRecord() (bool, error) {
for {
// Check that we have data in the internal buffer to read.
if r.writeIndex <= r.readIndex {
return false, nil
}
// Attempt to read a record, partial or otherwise.
temp, n, err := r.readRecord()
if err != nil {
return false, err
}
r.readIn... | go | {
"resource": ""
} |
q36917 | Add | train | func (es *MultiError) Add(err error) {
if err == nil {
return
}
if merr, ok := err.(MultiError); ok {
*es = append(*es, merr...)
} else {
*es = append(*es, err)
}
} | go | {
"resource": ""
} |
q36918 | OpenWriteSegment | train | func OpenWriteSegment(logger log.Logger, dir string, k int) (*Segment, error) {
segName := SegmentName(dir, k)
f, err := os.OpenFile(segName, os.O_WRONLY|os.O_APPEND, 0666)
if err != nil {
return nil, err
}
stat, err := f.Stat()
if err != nil {
f.Close()
return nil, err
}
// If the last page is torn, fill... | go | {
"resource": ""
} |
q36919 | CreateSegment | train | func CreateSegment(dir string, k int) (*Segment, error) {
f, err := os.OpenFile(SegmentName(dir, k), os.O_WRONLY|os.O_CREATE|os.O_APPEND, 0666)
if err != nil {
return nil, err
}
return &Segment{File: f, i: k, dir: dir}, nil
} | go | {
"resource": ""
} |
q36920 | OpenReadSegment | train | func OpenReadSegment(fn string) (*Segment, error) {
k, err := strconv.Atoi(filepath.Base(fn))
if err != nil {
return nil, errors.New("not a valid filename")
}
f, err := os.Open(fn)
if err != nil {
return nil, err
}
return &Segment{File: f, i: k, dir: filepath.Dir(fn)}, nil
} | go | {
"resource": ""
} |
q36921 | New | train | func New(logger log.Logger, reg prometheus.Registerer, dir string) (*WAL, error) {
return NewSize(logger, reg, dir, DefaultSegmentSize)
} | go | {
"resource": ""
} |
q36922 | NewSize | train | func NewSize(logger log.Logger, reg prometheus.Registerer, dir string, segmentSize int) (*WAL, error) {
if segmentSize%pageSize != 0 {
return nil, errors.New("invalid segment size")
}
if err := os.MkdirAll(dir, 0777); err != nil {
return nil, errors.Wrap(err, "create dir")
}
if logger == nil {
logger = log.N... | go | {
"resource": ""
} |
q36923 | Repair | train | func (w *WAL) Repair(origErr error) error {
// We could probably have a mode that only discards torn records right around
// the corruption to preserve as data much as possible.
// But that's not generally applicable if the records have any kind of causality.
// Maybe as an extra mode in the future if mid-WAL corru... | go | {
"resource": ""
} |
q36924 | SegmentName | train | func SegmentName(dir string, i int) string {
return filepath.Join(dir, fmt.Sprintf("%08d", i))
} | go | {
"resource": ""
} |
q36925 | nextSegment | train | func (w *WAL) nextSegment() error {
// Only flush the current page if it actually holds data.
if w.page.alloc > 0 {
if err := w.flushPage(true); err != nil {
return err
}
}
next, err := CreateSegment(w.dir, w.segment.Index()+1)
if err != nil {
return errors.Wrap(err, "create new segment file")
}
prev :=... | go | {
"resource": ""
} |
q36926 | flushPage | train | func (w *WAL) flushPage(clear bool) error {
w.pageFlushes.Inc()
p := w.page
clear = clear || p.full()
// No more data will fit into the page. Enqueue and clear it.
if clear {
p.alloc = pageSize // Write till end of page.
w.pageCompletions.Inc()
}
n, err := w.segment.Write(p.buf[p.flushed:p.alloc])
if err ... | go | {
"resource": ""
} |
q36927 | Log | train | func (w *WAL) Log(recs ...[]byte) error {
w.mtx.Lock()
defer w.mtx.Unlock()
// Callers could just implement their own list record format but adding
// a bit of extra logic here frees them from that overhead.
for i, r := range recs {
if err := w.log(r, i == len(recs)-1); err != nil {
return err
}
}
return ... | go | {
"resource": ""
} |
q36928 | log | train | func (w *WAL) log(rec []byte, final bool) error {
// If the record is too big to fit within the active page in the current
// segment, terminate the active segment and advance to the next one.
// This ensures that records do not cross segment boundaries.
left := w.page.remaining() - recordHeaderSize ... | go | {
"resource": ""
} |
q36929 | Truncate | train | func (w *WAL) Truncate(i int) (err error) {
w.truncateTotal.Inc()
defer func() {
if err != nil {
w.truncateFail.Inc()
}
}()
refs, err := listSegments(w.dir)
if err != nil {
return err
}
for _, r := range refs {
if r.index >= i {
break
}
if err = os.Remove(filepath.Join(w.dir, r.name)); err != n... | go | {
"resource": ""
} |
q36930 | Close | train | func (w *WAL) Close() (err error) {
w.mtx.Lock()
defer w.mtx.Unlock()
if w.closed {
return errors.New("wal already closed")
}
// Flush the last page and zero out all its remaining size.
// We must not flush an empty page as it would falsely signal
// the segment is done if we start writing to it again after ... | go | {
"resource": ""
} |
q36931 | NewSegmentsRangeReader | train | func NewSegmentsRangeReader(sr ...SegmentRange) (io.ReadCloser, error) {
var segs []*Segment
for _, sgmRange := range sr {
refs, err := listSegments(sgmRange.Dir)
if err != nil {
return nil, errors.Wrapf(err, "list segment in dir:%v", sgmRange.Dir)
}
for _, r := range refs {
if sgmRange.First >= 0 && ... | go | {
"resource": ""
} |
q36932 | NewTOCFromByteSlice | train | func NewTOCFromByteSlice(bs ByteSlice) (*TOC, error) {
if bs.Len() < indexTOCLen {
return nil, encoding.ErrInvalidSize
}
b := bs.Range(bs.Len()-indexTOCLen, bs.Len())
expCRC := binary.BigEndian.Uint32(b[len(b)-4:])
d := encoding.Decbuf{B: b[:len(b)-4]}
if d.Crc32(castagnoliTable) != expCRC {
return nil, err... | go | {
"resource": ""
} |
q36933 | NewWriter | train | func NewWriter(fn string) (*Writer, error) {
dir := filepath.Dir(fn)
df, err := fileutil.OpenDir(dir)
if err != nil {
return nil, err
}
defer df.Close() // Close for platform windows.
if err := os.RemoveAll(fn); err != nil {
return nil, errors.Wrap(err, "remove any existing index at path")
}
f, err := os... | go | {
"resource": ""
} |
q36934 | addPadding | train | func (w *Writer) addPadding(size int) error {
p := w.pos % uint64(size)
if p == 0 {
return nil
}
p = uint64(size) - p
return errors.Wrap(w.write(make([]byte, p)), "add padding")
} | go | {
"resource": ""
} |
q36935 | ensureStage | train | func (w *Writer) ensureStage(s indexWriterStage) error {
if w.stage == s {
return nil
}
if w.stage > s {
return errors.Errorf("invalid stage %q, currently at %q", s, w.stage)
}
// Mark start of sections in table of contents.
switch s {
case idxStageSymbols:
w.toc.Symbols = w.pos
case idxStageSeries:
w.... | go | {
"resource": ""
} |
q36936 | writeOffsetTable | train | func (w *Writer) writeOffsetTable(entries []hashEntry) error {
w.buf2.Reset()
w.buf2.PutBE32int(len(entries))
for _, e := range entries {
w.buf2.PutUvarint(len(e.keys))
for _, k := range e.keys {
w.buf2.PutUvarintStr(k)
}
w.buf2.PutUvarint64(e.offset)
}
w.buf1.Reset()
w.buf1.PutBE32int(w.buf2.Len())
... | go | {
"resource": ""
} |
q36937 | NewReader | train | func NewReader(b ByteSlice) (*Reader, error) {
return newReader(b, ioutil.NopCloser(nil))
} | go | {
"resource": ""
} |
q36938 | NewFileReader | train | func NewFileReader(path string) (*Reader, error) {
f, err := fileutil.OpenMmapFile(path)
if err != nil {
return nil, err
}
r, err := newReader(realByteSlice(f.Bytes()), f)
if err != nil {
var merr tsdb_errors.MultiError
merr.Add(err)
merr.Add(f.Close())
return nil, merr
}
return r, nil
} | go | {
"resource": ""
} |
q36939 | PostingsRanges | train | func (r *Reader) PostingsRanges() (map[labels.Label]Range, error) {
m := map[labels.Label]Range{}
for k, e := range r.postings {
for v, start := range e {
d := encoding.NewDecbufAt(r.b, int(start), castagnoliTable)
if d.Err() != nil {
return nil, d.Err()
}
m[labels.Label{Name: k, Value: v}] = Range... | go | {
"resource": ""
} |
q36940 | ReadSymbols | train | func ReadSymbols(bs ByteSlice, version int, off int) ([]string, map[uint32]string, error) {
if off == 0 {
return nil, nil, nil
}
d := encoding.NewDecbufAt(bs, off, castagnoliTable)
var (
origLen = d.Len()
cnt = d.Be32int()
basePos = uint32(off) + 4
nextPos = basePos + uint32(origLen-d... | go | {
"resource": ""
} |
q36941 | ReadOffsetTable | train | func ReadOffsetTable(bs ByteSlice, off uint64, f func([]string, uint64) error) error {
d := encoding.NewDecbufAt(bs, int(off), castagnoliTable)
cnt := d.Be32()
for d.Err() == nil && d.Len() > 0 && cnt > 0 {
keyCount := d.Uvarint()
keys := make([]string, 0, keyCount)
for i := 0; i < keyCount; i++ {
keys = ... | go | {
"resource": ""
} |
q36942 | Symbols | train | func (r *Reader) Symbols() (map[string]struct{}, error) {
res := make(map[string]struct{}, len(r.symbolsV1)+len(r.symbolsV2))
for _, s := range r.symbolsV1 {
res[s] = struct{}{}
}
for _, s := range r.symbolsV2 {
res[s] = struct{}{}
}
return res, nil
} | go | {
"resource": ""
} |
q36943 | LabelValues | train | func (r *Reader) LabelValues(names ...string) (StringTuples, error) {
key := strings.Join(names, labelNameSeperator)
off, ok := r.labels[key]
if !ok {
// XXX(fabxc): hot fix. Should return a partial data error and handle cases
// where the entire block has no data gracefully.
return emptyStringTuples{}, nil
... | go | {
"resource": ""
} |
q36944 | Series | train | func (r *Reader) Series(id uint64, lbls *labels.Labels, chks *[]chunks.Meta) error {
offset := id
// In version 2 series IDs are no longer exact references but series are 16-byte padded
// and the ID is the multiple of 16 of the actual position.
if r.version == FormatV2 {
offset = id * 16
}
d := encoding.NewDec... | go | {
"resource": ""
} |
q36945 | Postings | train | func (r *Reader) Postings(name, value string) (Postings, error) {
e, ok := r.postings[name]
if !ok {
return EmptyPostings(), nil
}
off, ok := e[value]
if !ok {
return EmptyPostings(), nil
}
d := encoding.NewDecbufAt(r.b, int(off), castagnoliTable)
if d.Err() != nil {
return nil, errors.Wrap(d.Err(), "get ... | go | {
"resource": ""
} |
q36946 | LabelNames | train | func (r *Reader) LabelNames() ([]string, error) {
labelNamesMap := make(map[string]struct{}, len(r.labels))
for key := range r.labels {
// 'key' contains the label names concatenated with the
// delimiter 'labelNameSeperator'.
names := strings.Split(key, labelNameSeperator)
for _, name := range names {
if ... | go | {
"resource": ""
} |
q36947 | Postings | train | func (dec *Decoder) Postings(b []byte) (int, Postings, error) {
d := encoding.Decbuf{B: b}
n := d.Be32int()
l := d.Get()
return n, newBigEndianPostings(l), d.Err()
} | go | {
"resource": ""
} |
q36948 | Series | train | func (dec *Decoder) Series(b []byte, lbls *labels.Labels, chks *[]chunks.Meta) error {
*lbls = (*lbls)[:0]
*chks = (*chks)[:0]
d := encoding.Decbuf{B: b}
k := d.Uvarint()
for i := 0; i < k; i++ {
lno := uint32(d.Uvarint())
lvo := uint32(d.Uvarint())
if d.Err() != nil {
return errors.Wrap(d.Err(), "rea... | go | {
"resource": ""
} |
q36949 | Matches | train | func (s Selector) Matches(labels Labels) bool {
for _, m := range s {
if v := labels.Get(m.Name()); !m.Matches(v) {
return false
}
}
return true
} | go | {
"resource": ""
} |
q36950 | NewEqualMatcher | train | func NewEqualMatcher(name, value string) Matcher {
return &EqualMatcher{name: name, value: value}
} | go | {
"resource": ""
} |
q36951 | NewRegexpMatcher | train | func NewRegexpMatcher(name, pattern string) (Matcher, error) {
re, err := regexp.Compile(pattern)
if err != nil {
return nil, err
}
return ®expMatcher{name: name, re: re}, nil
} | go | {
"resource": ""
} |
q36952 | NewMustRegexpMatcher | train | func NewMustRegexpMatcher(name, pattern string) Matcher {
re, err := regexp.Compile(pattern)
if err != nil {
panic(err)
}
return ®expMatcher{name: name, re: re}
} | go | {
"resource": ""
} |
q36953 | writeHash | train | func (cm *Meta) writeHash(h hash.Hash) error {
if _, err := h.Write([]byte{byte(cm.Chunk.Encoding())}); err != nil {
return err
}
if _, err := h.Write(cm.Chunk.Bytes()); err != nil {
return err
}
return nil
} | go | {
"resource": ""
} |
q36954 | NewWriter | train | func NewWriter(dir string) (*Writer, error) {
if err := os.MkdirAll(dir, 0777); err != nil {
return nil, err
}
dirFile, err := fileutil.OpenDir(dir)
if err != nil {
return nil, err
}
cw := &Writer{
dirFile: dirFile,
n: 0,
crc32: newCRC32(),
segmentSize: defaultChunkSegmentSize,
}
... | go | {
"resource": ""
} |
q36955 | finalizeTail | train | func (w *Writer) finalizeTail() error {
tf := w.tail()
if tf == nil {
return nil
}
if err := w.wbuf.Flush(); err != nil {
return err
}
if err := tf.Sync(); err != nil {
return err
}
// As the file was pre-allocated, we truncate any superfluous zero bytes.
off, err := tf.Seek(0, io.SeekCurrent)
if err !... | go | {
"resource": ""
} |
q36956 | MergeChunks | train | func MergeChunks(a, b chunkenc.Chunk) (*chunkenc.XORChunk, error) {
newChunk := chunkenc.NewXORChunk()
app, err := newChunk.Appender()
if err != nil {
return nil, err
}
ait := a.Iterator()
bit := b.Iterator()
aok, bok := ait.Next(), bit.Next()
for aok && bok {
at, av := ait.At()
bt, bv := bit.At()
if at... | go | {
"resource": ""
} |
q36957 | NewDirReader | train | func NewDirReader(dir string, pool chunkenc.Pool) (*Reader, error) {
files, err := sequenceFiles(dir)
if err != nil {
return nil, err
}
if pool == nil {
pool = chunkenc.NewPool()
}
var (
bs []ByteSlice
cs []io.Closer
merr tsdb_errors.MultiError
)
for _, fn := range files {
f, err := fileutil.Op... | go | {
"resource": ""
} |
q36958 | Chunk | train | func (s *Reader) Chunk(ref uint64) (chunkenc.Chunk, error) {
var (
sgmSeq = int(ref >> 32)
sgmOffset = int((ref << 32) >> 32)
)
if sgmSeq >= len(s.bs) {
return nil, errors.Errorf("reference sequence %d out of range", sgmSeq)
}
chkS := s.bs[sgmSeq]
if sgmOffset >= chkS.Len() {
return nil, errors.Errorf... | go | {
"resource": ""
} |
q36959 | NewXORChunk | train | func NewXORChunk() *XORChunk {
b := make([]byte, 2, 128)
return &XORChunk{b: bstream{stream: b, count: 0}}
} | go | {
"resource": ""
} |
q36960 | NumSamples | train | func (c *XORChunk) NumSamples() int {
return int(binary.BigEndian.Uint16(c.Bytes()))
} | go | {
"resource": ""
} |
q36961 | Appender | train | func (c *XORChunk) Appender() (Appender, error) {
it := c.iterator()
// To get an appender we must know the state it would have if we had
// appended all existing data from scratch.
// We iterate through the end and populate via the iterator's state.
for it.Next() {
}
if err := it.Err(); err != nil {
return n... | go | {
"resource": ""
} |
q36962 | DeleteRegistrationByName | train | func (mc MongoClient) DeleteRegistrationByName(name string) error {
return mc.deleteRegistration(bson.M{"name": name})
} | go | {
"resource": ""
} |
q36963 | getRegistrations | train | func (mc MongoClient) getRegistrations(q bson.M) ([]models.Registration, error) {
s := mc.getSessionCopy()
defer s.Close()
var regs []models.Registration
err := s.DB(mc.database.Name).C(db.ExportCollection).Find(q).All(®s)
if err != nil {
return []models.Registration{}, errorMap(err)
}
return regs, nil
} | go | {
"resource": ""
} |
q36964 | getRegistration | train | func (mc MongoClient) getRegistration(q bson.M) (models.Registration, error) {
s := mc.getSessionCopy()
defer s.Close()
var reg models.Registration
err := s.DB(mc.database.Name).C(db.ExportCollection).Find(q).One(®)
if err != nil {
return models.Registration{}, errorMap(err)
}
return reg, nil
} | go | {
"resource": ""
} |
q36965 | newDBClient | train | func newDBClient(dbType string) (interfaces.DBClient, error) {
switch dbType {
case db.MongoDB:
dbConfig := db.Configuration{
Host: Configuration.Databases["Primary"].Host,
Port: Configuration.Databases["Primary"].Port,
Timeout: Configuration.Databases["Primary"].Timeout,
DatabaseNa... | go | {
"resource": ""
} |
q36966 | pingHandler | train | func pingHandler(w http.ResponseWriter, _ *http.Request) {
w.Header().Set("Content-Type", "text/plain")
w.Write([]byte("pong"))
} | go | {
"resource": ""
} |
q36967 | EventsWithLimit | train | func (mc MongoClient) EventsWithLimit(limit int) ([]contract.Event, error) {
return mc.mapEvents(mc.getEventsLimit(bson.M{}, limit))
} | go | {
"resource": ""
} |
q36968 | EventCount | train | func (mc MongoClient) EventCount() (int, error) {
s := mc.getSessionCopy()
defer s.Close()
count, err := s.DB(mc.database.Name).C(db.EventsCollection).Find(nil).Count()
if err != nil {
return 0, errorMap(err)
}
return count, nil
} | go | {
"resource": ""
} |
q36969 | EventCountByDeviceId | train | func (mc MongoClient) EventCountByDeviceId(id string) (int, error) {
s := mc.getSessionCopy()
defer s.Close()
query := bson.M{"device": id}
count, err := s.DB(mc.database.Name).C(db.EventsCollection).Find(query).Count()
if err != nil {
return 0, errorMap(err)
}
return count, nil
} | go | {
"resource": ""
} |
q36970 | DeleteEventById | train | func (mc MongoClient) DeleteEventById(id string) error {
return mc.deleteById(db.EventsCollection, id)
} | go | {
"resource": ""
} |
q36971 | EventsForDeviceLimit | train | func (mc MongoClient) EventsForDeviceLimit(id string, limit int) ([]contract.Event, error) {
return mc.mapEvents(mc.getEventsLimit(bson.M{"device": id}, limit))
} | go | {
"resource": ""
} |
q36972 | EventsByCreationTime | train | func (mc MongoClient) EventsByCreationTime(startTime, endTime int64, limit int) ([]contract.Event, error) {
query := bson.M{"created": bson.M{
"$gte": startTime,
"$lte": endTime,
}}
return mc.mapEvents(mc.getEventsLimit(query, limit))
} | go | {
"resource": ""
} |
q36973 | EventsPushed | train | func (mc MongoClient) EventsPushed() ([]contract.Event, error) {
return mc.mapEvents(mc.getEvents(bson.M{"pushed": bson.M{"$gt": int64(0)}}))
} | go | {
"resource": ""
} |
q36974 | ScrubAllEvents | train | func (mc MongoClient) ScrubAllEvents() error {
s := mc.getSessionCopy()
defer s.Close()
_, err := s.DB(mc.database.Name).C(db.ReadingsCollection).RemoveAll(nil)
if err != nil {
return errorMap(err)
}
_, err = s.DB(mc.database.Name).C(db.EventsCollection).RemoveAll(nil)
if err != nil {
return errorMap(err)
... | go | {
"resource": ""
} |
q36975 | getEvents | train | func (mc MongoClient) getEvents(q bson.M) (me []models.Event, err error) {
s := mc.getSessionCopy()
defer s.Close()
err = s.DB(mc.database.Name).C(db.EventsCollection).Find(q).All(&me)
if err != nil {
return []models.Event{}, errorMap(err)
}
return
} | go | {
"resource": ""
} |
q36976 | getEventsLimit | train | func (mc MongoClient) getEventsLimit(q bson.M, limit int) (me []models.Event, err error) {
s := mc.getSessionCopy()
defer s.Close()
// Check if limit is 0
if limit == 0 {
return []models.Event{}, nil
}
err = s.DB(mc.database.Name).C(db.EventsCollection).Find(q).Sort("-modified").Limit(limit).All(&me)
if err ... | go | {
"resource": ""
} |
q36977 | Readings | train | func (mc MongoClient) Readings() ([]contract.Reading, error) {
readings, err := mc.getReadings(nil)
if err != nil {
return []contract.Reading{}, err
}
mapped := make([]contract.Reading, 0)
for _, r := range readings {
mapped = append(mapped, r.ToContract())
}
return mapped, nil
} | go | {
"resource": ""
} |
q36978 | AddReading | train | func (mc MongoClient) AddReading(r contract.Reading) (string, error) {
s := mc.getSessionCopy()
defer s.Close()
var mapped models.Reading
id, err := mapped.FromContract(r)
if err != nil {
return "", err
}
mapped.TimestampForAdd()
err = s.DB(mc.database.Name).C(db.ReadingsCollection).Insert(&mapped)
if err... | go | {
"resource": ""
} |
q36979 | ReadingCount | train | func (mc MongoClient) ReadingCount() (int, error) {
s := mc.getSessionCopy()
defer s.Close()
count, err := s.DB(mc.database.Name).C(db.ReadingsCollection).Find(bson.M{}).Count()
if err != nil {
return 0, errorMap(err)
}
return count, nil
} | go | {
"resource": ""
} |
q36980 | ReadingsByValueDescriptor | train | func (mc MongoClient) ReadingsByValueDescriptor(name string, limit int) ([]contract.Reading, error) {
return mapReadings(mc.getReadingsLimit(bson.M{"name": name}, limit))
} | go | {
"resource": ""
} |
q36981 | ReadingsByValueDescriptorNames | train | func (mc MongoClient) ReadingsByValueDescriptorNames(names []string, limit int) ([]contract.Reading, error) {
return mapReadings(mc.getReadingsLimit(bson.M{"name": bson.M{"$in": names}}, limit))
} | go | {
"resource": ""
} |
q36982 | ReadingsByCreationTime | train | func (mc MongoClient) ReadingsByCreationTime(start, end int64, limit int) ([]contract.Reading, error) {
return mapReadings(mc.getReadingsLimit(bson.M{"created": bson.M{"$gte": start, "$lte": end}}, limit))
} | go | {
"resource": ""
} |
q36983 | getReadingsLimit | train | func (mc MongoClient) getReadingsLimit(q bson.M, limit int) ([]models.Reading, error) {
s := mc.getSessionCopy()
defer s.Close()
// Check if limit is 0
if limit == 0 {
return []models.Reading{}, nil
}
var readings []models.Reading
if err := s.DB(mc.database.Name).C(db.ReadingsCollection).Find(q).Sort("-modif... | go | {
"resource": ""
} |
q36984 | getReading | train | func (mc MongoClient) getReading(q bson.M) (models.Reading, error) {
s := mc.getSessionCopy()
defer s.Close()
var res models.Reading
if err := s.DB(mc.database.Name).C(db.ReadingsCollection).Find(q).One(&res); err != nil {
return models.Reading{}, errorMap(err)
}
return res, nil
} | go | {
"resource": ""
} |
q36985 | DeleteValueDescriptorById | train | func (mc MongoClient) DeleteValueDescriptorById(id string) error {
return mc.deleteById(db.ValueDescriptorCollection, id)
} | go | {
"resource": ""
} |
q36986 | ValueDescriptorByName | train | func (mc MongoClient) ValueDescriptorByName(name string) (contract.ValueDescriptor, error) {
mvd, err := mc.getValueDescriptor(bson.M{"name": name})
if err != nil {
return contract.ValueDescriptor{}, err
}
return mvd.ToContract(), nil
} | go | {
"resource": ""
} |
q36987 | ValueDescriptorsByName | train | func (mc MongoClient) ValueDescriptorsByName(names []string) ([]contract.ValueDescriptor, error) {
vList := make([]contract.ValueDescriptor, 0)
for _, name := range names {
v, err := mc.ValueDescriptorByName(name)
if err != nil && err != db.ErrNotFound {
return []contract.ValueDescriptor{}, err
}
if err ==... | go | {
"resource": ""
} |
q36988 | ValueDescriptorById | train | func (mc MongoClient) ValueDescriptorById(id string) (contract.ValueDescriptor, error) {
query, err := idToBsonM(id)
if err != nil {
return contract.ValueDescriptor{}, err
}
mvd, err := mc.getValueDescriptor(query)
if err != nil {
return contract.ValueDescriptor{}, err
}
return mvd.ToContract(), nil
} | go | {
"resource": ""
} |
q36989 | ValueDescriptorsByUomLabel | train | func (mc MongoClient) ValueDescriptorsByUomLabel(uomLabel string) ([]contract.ValueDescriptor, error) {
return mapValueDescriptors(mc.getValueDescriptors(bson.M{"uomLabel": uomLabel}))
} | go | {
"resource": ""
} |
q36990 | ValueDescriptorsByLabel | train | func (mc MongoClient) ValueDescriptorsByLabel(label string) ([]contract.ValueDescriptor, error) {
return mapValueDescriptors(mc.getValueDescriptors(bson.M{"labels": label}))
} | go | {
"resource": ""
} |
q36991 | ValueDescriptorsByType | train | func (mc MongoClient) ValueDescriptorsByType(t string) ([]contract.ValueDescriptor, error) {
return mapValueDescriptors(mc.getValueDescriptors(bson.M{"type": t}))
} | go | {
"resource": ""
} |
q36992 | ScrubAllValueDescriptors | train | func (mc MongoClient) ScrubAllValueDescriptors() error {
s := mc.getSessionCopy()
defer s.Close()
if _, err := s.DB(mc.database.Name).C(db.ValueDescriptorCollection).RemoveAll(nil); err != nil {
return errorMap(err)
}
return nil
} | go | {
"resource": ""
} |
q36993 | getValueDescriptors | train | func (mc MongoClient) getValueDescriptors(q bson.M) ([]models.ValueDescriptor, error) {
s := mc.getSessionCopy()
defer s.Close()
var v []models.ValueDescriptor
if err := s.DB(mc.database.Name).C(db.ValueDescriptorCollection).Find(q).All(&v); err != nil {
return []models.ValueDescriptor{}, errorMap(err)
}
retur... | go | {
"resource": ""
} |
q36994 | getValueDescriptor | train | func (mc MongoClient) getValueDescriptor(q bson.M) (models.ValueDescriptor, error) {
s := mc.getSessionCopy()
defer s.Close()
var m models.ValueDescriptor
if err := s.DB(mc.database.Name).C(db.ValueDescriptorCollection).Find(q).One(&m); err != nil {
return models.ValueDescriptor{}, errorMap(err)
}
return m, ni... | go | {
"resource": ""
} |
q36995 | GetSubscriptions | train | func (mc MongoClient) GetSubscriptions() ([]contract.Subscription, error) {
return mc.getSubscriptions(bson.M{})
} | go | {
"resource": ""
} |
q36996 | encode | train | func encode(i interface{}, w http.ResponseWriter) {
w.Header().Add("Content-Type", "application/json")
enc := json.NewEncoder(w)
err := enc.Encode(i)
// Problems encoding
if err != nil {
LoggingClient.Error("Error encoding the data: " + err.Error())
http.Error(w, err.Error(), http.StatusInternalServerError)
... | go | {
"resource": ""
} |
q36997 | deleteProvisionWatcher | train | func deleteProvisionWatcher(pw models.ProvisionWatcher, w http.ResponseWriter) error {
if err := dbClient.DeleteProvisionWatcherById(pw.Id); err != nil {
http.Error(w, err.Error(), http.StatusServiceUnavailable)
return err
}
if err := notifyProvisionWatcherAssociates(pw, http.MethodDelete); err != nil {
Loggi... | go | {
"resource": ""
} |
q36998 | restUpdateProvisionWatcher | train | func restUpdateProvisionWatcher(w http.ResponseWriter, r *http.Request) {
defer r.Body.Close()
var from models.ProvisionWatcher
if err := json.NewDecoder(r.Body).Decode(&from); err != nil {
LoggingClient.Error(err.Error())
http.Error(w, err.Error(), http.StatusServiceUnavailable)
return
}
// Check if the pr... | go | {
"resource": ""
} |
q36999 | updateProvisionWatcherFields | train | func updateProvisionWatcherFields(from models.ProvisionWatcher, to *models.ProvisionWatcher, w http.ResponseWriter) error {
if from.Identifiers != nil {
to.Identifiers = from.Identifiers
}
if from.Origin != 0 {
to.Origin = from.Origin
}
if from.Name != "" {
// Check that the name is unique
checkPW, err := ... | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.