id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1 value |
|---|---|---|
c181300 | ON %s.%s (expire_at DESC);
`, s.schema, s.schema, s.table, int64(s.ttl.Seconds()),
s.schema, s.table,
s.schema, s.table,
s.schema, s.table,
)
_, err := s.db.Exec(query)
return err
} | |
c181301 | + s.schema + ` CASCADE`)
return err
} | |
c181302 |
LocalAgentHostPort: agentAddress,
},
}
tracer, closer, err := cfg.New(service, config.Logger(zapjaeger.NewLogger(log)))
if err != nil {
return nil, nil, err
}
return tracer, closer, nil
} | |
c181303 | fmt.Fprintf(errorWriter, "usage: %s <command>\n", path.Base(os.Args[0]))
} | |
c181304 | s)
for i := range ids {
ids[i] = i + 1
}
return BuildWithIDs(keywords, ids)
} | |
c181305 | e := binary.Read(r, binary.LittleEndian, &d[i].Base); e != nil {
return d, e
}
if e := binary.Read(r, binary.LittleEndian, &d[i].Check); e != nil {
return d, e
}
}
return d, nil
} | |
c181306 | len(c.nodes)-1 < int(k) {
return nil, false
}
return c.nodes[k], true
} | |
c181307 | c.listen {
res = append(res, n)
}
}
return
} | |
c181308 | false
}
if node, ok := c.Get(jump.HashString(accessToken, c.Len())); ok {
if node.Addr != c.listen {
if node.Client != nil {
return node, true
}
}
}
return nil, false
} | |
c181309 | c.nodes,
"buckets": strconv.FormatInt(int64(c.buckets), 10),
})
return string(buf)
} | |
c181310 |
err = gob.NewDecoder(bytes.NewReader(t)).Decode(b)
default:
return errors.New("unsupported data source type")
}
return
} | |
c181311 |
err := gob.NewEncoder(buf).Encode(b)
if err != nil {
return nil, err
}
return buf.Bytes(), nil
} | |
c181312 | ok := (*b)[key]
return ok
} | |
c181313 | enc := gob.NewEncoder(&b)
if err = enc.Encode(idx.Dup); err != nil {
return
}
x, err := b.WriteTo(w)
if err != nil {
return
}
n += x
return
} | |
c181314 | := dec.Decode(&idx.Dup); e != nil {
return idx, fmt.Errorf("read index dup table error, %v", e)
}
return idx, nil
} | |
c181315 |
admin.GetRouter().Get("/action_bar/inline_edit", ctr.InlineEdit)
return bar
} | |
c181316 | append(bar.GlobalActions, action)
bar.actions = bar.GlobalActions
} | |
c181317 | newBar.actions = append(newBar.actions, actions...)
return newBar
} | |
c181318 | "Auth": bar.Admin.Auth,
"CurrentUser": context.Context.CurrentUser,
"Actions": actions,
"InlineActions": inlineActions,
"RouterPrefix": bar.Admin.GetRouter().Prefix,
}
return context.Render("action_bar/action_bar", result)
} | |
c181319 | ...*admin.Resource) template.HTML {
return bar.RenderEditButtonWithResource(w, r, value, resources...)
}
return funcMap
} | |
c181320 |
return isEditMode(bar.Admin.NewContext(w, r))
} | |
c181321 | == "" {
referrer = "/"
}
http.Redirect(context.Writer, context.Request, referrer, http.StatusFound)
} | |
c181322 | context.Writer.Write([]byte(context.Render("action_bar/inline_edit")))
} | |
c181323 | e.Filename, e.LineNum, e.Msg)
} | |
c181324 | {
return nil, nil, err
}
defer fd.Close()
return parse(fd, &filePos{filename, 1})
} | |
c181325 |
for _, m := range mach {
if m.Name == name {
return m, nil
}
if m.Name == "" {
def = m
}
}
if def == nil {
return nil, errors.New("no machine found")
}
return def, nil
} | |
c181326 | return nil, fmt.Errorf("kace: cannot create trie: %s", err)
}
k := &Kace{
t: t,
}
return k, nil
} | |
c181327 | camelCase(k.t, s, false)
} | |
c181328 | camelCase(k.t, s, true)
} | |
c181329 | {
return delimitedCase(s, snakeDelim, false)
} | |
c181330 | delimitedCase(s, snakeDelim, true)
} | |
c181331 | {
return delimitedCase(s, kebabDelim, false)
} | |
c181332 | delimitedCase(s, kebabDelim, true)
} | |
c181333 | return fmt.Errorf(errorMessage)
}
if !whitelistPattern.MatchString(e) {
return fmt.Errorf(errorMessage)
}
return nil
} | |
c181334 | = r.URL.String()
t.Request.Method = r.Method
} | |
c181335 | Name: "Authorization",
Message: err.Error()})
}
pair := strings.SplitN(string(payload), ":", 2)
if len(pair) != 2 {
return nil, trace.Wrap(
&ParameterError{
Name: "Authorization",
Message: "bad header"})
}
return &AuthCreds{Type: AuthBasic, Username: pair[0], Password: pair[1]}, nil
case AuthBearer:
return &AuthCreds{Type: AuthBearer, Password: auth[1]}, nil
}
return nil, trace.Wrap(
&ParameterError{
Name: "Authorization",
Message: "unsupported auth scheme"})
} | |
c181336 |
c.newTracer = newTracer
return nil
}
} | |
c181337 | error {
c.client = h
return nil
}
} | |
c181338 | *Client) error {
c.auth = &basicAuth{username: username, password: password}
return nil
}
} | |
c181339 | *Client) error {
c.auth = &bearerAuth{token: token}
return nil
}
} | |
c181340 | *Client) error {
c.jar = jar
return nil
}
} | |
c181341 | return func(c *Client) error {
c.sanitizerEnabled = sanitizerEnabled
return nil
}
} | |
c181342 |
if c.sanitizerEnabled {
err := isPathSafe(endpoint)
if err != nil {
return nil, err
}
}
u, err := url.Parse(endpoint)
if err != nil {
return nil, err
}
u.RawQuery = params.Encode()
return newSeeker(c, ctx, u.String())
} | |
c181343 | return nil, err
}
return &Response{
code: re.StatusCode,
headers: re.Header,
body: buf,
cookies: re.Cookies(),
}, nil
} | |
c181344 | h.Set("Authorization", c.auth.String())
}
} | |
c181345 | == 0 {
return ""
}
_, params, err := mime.ParseMediaType(value)
if err != nil {
return ""
}
return params["filename"]
} | |
c181346 | {
buffers = append(buffers, newFileBuffer(file))
}
return buffers
} | |
c181347 | Reader: io.TeeReader(file.Reader, buf),
File: file,
cache: buf,
}
} | |
c181348 | = io.MultiReader(r.cache, r.File.Reader)
} | |
c181349 | }
return nil, trace.Wrap(err)
}
return re, trace.ReadError(re.Code(), re.Bytes())
} | |
c181350 | return err
}
o.Source = "override"
o.Defined = true
return nil
} | |
c181351 | return nil
}
return fmt.Errorf("Got %T expected %T type: %v", value, o.Value, value)
} | |
c181352 | return fmt.Sprintf("{Source:%s Defined:%t Value:%v}", o.Source, o.Defined, o.Value)
} | |
c181353 |
return trigger(description, key, map[string]interface{}{})
} | |
c181354 | {
return trigger(description, "", details)
} | |
c181355 | error) {
return trigger(description, key, details)
} | |
c181356 |
m.mergeStructs(reflect.ValueOf(dst), reflect.ValueOf(src))
} | |
c181357 | i := 0; i < v.NumField(); i++ {
structField := v.Type().Field(i)
// PkgPath is empty for upper case (exported) field names.
if structField.PkgPath != "" {
// unexported field, skipping
continue
}
m.setSource(v.Field(i))
}
case reflect.Array:
fallthrough
case reflect.Slice:
for i := 0; i < v.Len(); i++ {
m.setSource(v.Index(i))
}
}
} | |
c181358 | err = strconv.ParseUint(src, 10, 32)
*v = uint(tmp)
case *uint8:
var tmp uint64
tmp, err = strconv.ParseUint(src, 10, 8)
*v = uint8(tmp)
case *uint16:
var tmp uint64
tmp, err = strconv.ParseUint(src, 10, 16)
*v = uint16(tmp)
case *uint32:
var tmp uint64
tmp, err = strconv.ParseUint(src, 10, 32)
*v = uint32(tmp)
case *uint64:
var tmp uint64
tmp, err = strconv.ParseUint(src, 10, 64)
*v = uint64(tmp)
// hmm, collides with uint8
// case *byte:
// tmp := []byte(src)
// if len(tmp) == 1 {
// *v = tmp[0]
// } else {
// err = fmt.Errorf("Cannot convert string %q to byte, length: %d", src, len(tmp))
// }
// hmm, collides with int32
// case *rune:
// tmp := []rune(src)
// if len(tmp) == 1 {
// *v = tmp[0]
// } else {
// err = fmt.Errorf("Cannot convert string %q to rune, lengt: %d", src, len(tmp))
// }
case *float32:
var tmp float64
tmp, err = strconv.ParseFloat(src, 32)
*v = float32(tmp)
case *float64:
var tmp float64
tmp, err = strconv.ParseFloat(src, 64)
*v = float64(tmp)
default:
err = fmt.Errorf("Cannot convert string %q to type %T", src, dst)
}
if err != nil {
return err
}
return nil
} | |
c181359 | {
return err
}
defer t.TxFinish()
err = f(t)
if err != nil {
return err
}
return t.TxCommit()
} | |
c181360 |
file, _ := os.Create(filename)
return file
} | |
c181361 | go doRequest(b.request, b.timeout, sem, out)
}
fmt.Print("\nWaiting for threads to finish ")
for i := sem.Length(); i != 0; i = sem.Length() {
//abandon <- true
time.Sleep(200 * time.Millisecond)
}
fmt.Println(" OK")
fmt.Println("")
close(out)
return <-resultsChan
} | |
c181362 | %v\n", rStr, r.TotalSuccess)
rStr = fmt.Sprintf("%vTotal Timeouts: %v\n", rStr, r.TotalTimeouts)
return fmt.Sprintf("%vTotal Failures: %v\n", rStr, r.TotalFailures)
} | |
c181363 | if _, ok := r.Error.(errors.Timeout); ok {
row.TotalTimeouts++
}
row.TotalFailures++
} else {
row.TotalSuccess++
totalRequestTime += r.RequestTime
}
if r.Threads > maxThreads {
maxThreads = r.Threads
row.Threads = maxThreads
}
}
if totalRequestTime != 0 && row.TotalSuccess != 0 {
avgTime := int64(totalRequestTime) / int64(row.TotalSuccess)
row.AvgRequestTime = time.Duration(avgTime)
}
rows = append(rows, row)
}
}
return rows
} | |
c181364 | }
}(resp)
if err != nil || resp.StatusCode != 200 {
return err
}
return nil
} | |
c181365 |
for _, row := range rows {
w.Write([]byte(row.String()))
w.Write([]byte("\n"))
}
} | |
c181366 | currentBucket := getBucketNumber(result.Timestamp, start, end, interval, bucketCount)
buckets[currentBucket] = append(buckets[currentBucket], result)
}
return buckets
} | |
c181367 | rampUp < 1 {
s.s = make(chan struct{}, capacity)
} else {
s.s = make(chan struct{}, 1)
go s.rampUpThreads(capacity, rampUp)
}
s.resizeUnlock()
return &s
} | |
c181368 | make sure we have not called Release without Lock
if len(t.s) == 0 {
return
}
<-t.s
} | |
c181369 | // create the new semaphore with the new capcity
// copy the old values
for n := len(t.s); n != 0; n = len(t.s) {
new <- <-t.s // copy elements to the new channel
}
t.s = new
} | |
c181370 |
o := outputContainer{
interval: interval,
writer: writer,
function: output,
}
b.outputs = append(b.outputs, o)
} | |
c181371 | := b.internalRun(b.showProgress)
b.processResults(results)
} | |
c181372 | // Thus only 0 and 255 are valid encoded values.
switch bytes[0] {
case 0:
ret = false
case 0xff:
ret = true
default:
err = asn1.SyntaxError{Msg: "invalid boolean"}
}
return
} | |
c181373 | (bytes[0] == 0xff && bytes[1]&0x80 == 0x80) {
return asn1.StructuralError{Msg: "integer not minimally-encoded"}
}
return nil
} | |
c181374 |
ret <<= 8
ret |= int64(bytes[bytesRead])
}
// Shift up and down in order to sign extend the result.
ret <<= 64 - uint8(len(bytes))*8
ret >>= 64 - uint8(len(bytes))*8
return
} | |
c181375 | != int64(int32(ret64)) {
return 0, asn1.StructuralError{Msg: "integer too large"}
}
return int32(ret64), nil
} | |
c181376 | for i := range notBytes {
notBytes[i] = ^bytes[i]
}
ret.SetBytes(notBytes)
ret.Add(ret, bigOne)
ret.Neg(ret)
return ret, nil
}
ret.SetBytes(bytes)
return ret, nil
} | |
c181377 | bytes[len(bytes)-1]&((1<<bytes[0])-1) != 0 {
err = asn1.SyntaxError{Msg: "invalid padding bits in BIT STRING"}
return
}
ret.BitLength = (len(bytes)-1)*8 - paddingBits
ret.Bytes = bytes[1:]
return
} | |
c181378 | = 2,
// then there are no restrictions on value2.
v, offset, err := _parseBase128Int(bytes, 0)
if err != nil {
return
}
if v < 80 {
s[0] = v / 40
s[1] = v % 40
} else {
s[0] = 2
s[1] = v - 80
}
i := 2
for ; offset < len(bytes); i++ {
v, offset, err = _parseBase128Int(bytes, offset)
if err != nil {
return
}
s[i] = v
}
s = s[0:i]
return
} | |
c181379 |
err = asn1.StructuralError{Msg: "base 128 integer too large"}
return
}
return
} | |
c181380 | s {
err = fmt.Errorf("asn1: time did not serialize back to the original value and may be invalid: given %q, but serialized as %q", s, serialized)
}
return
} | |
c181381 | contains invalid character"}
return
}
}
ret = string(bytes)
return
} | |
c181382 | PrintableString.
// However, x509 certificates with wildcard strings don't
// always use the correct string type so we permit it.
b == '*'
} | |
c181383 | != classUniversal || t.isCompound != compoundType || t.tag != expectedTag {
err = asn1.StructuralError{Msg: "sequence tag mismatch"}
return
}
if invalidLength(offset, t.length, len(bytes)) {
err = asn1.SyntaxError{Msg: "truncated sequence"}
return
}
offset += t.length
numElements++
}
ret = reflect.MakeSlice(sliceType, numElements, numElements)
params := fieldParameters{}
offset := 0
for i := 0; i < numElements; i++ {
offset, err = parseField(ret.Index(i), bytes, offset, params)
if err != nil {
return
}
}
return
} | |
c181384 | offset+length < offset || offset+length > sliceLength
} | |
c181385 |
if canHaveDefaultValue(v.Kind()) {
v.SetInt(*params.defaultValue)
}
return
} | |
c181386 |
offset, err := parseField(v, b, 0, parseFieldParameters(params))
if err != nil {
return nil, err
}
return b[offset:], nil
} | |
c181387 | == "printable":
ret.stringType = tagPrintableString
case part == "utf8":
ret.stringType = tagUTF8String
case strings.HasPrefix(part, "default:"):
i, err := strconv.ParseInt(part[8:], 10, 64)
if err == nil {
ret.defaultValue = new(int64)
*ret.defaultValue = i
}
case strings.HasPrefix(part, "tag:"):
i, err := strconv.Atoi(part[4:])
if err == nil {
ret.tag = new(int)
*ret.tag = i
}
case part == "set":
ret.set = true
case part == "application":
ret.application = true
if ret.tag == nil {
ret.tag = new(int)
}
case part == "omitempty":
ret.omitEmpty = true
}
}
return
} | |
c181388 |
if t.Elem().Kind() == reflect.Uint8 {
return tagOctetString, false, true
}
if strings.HasSuffix(t.Name(), "SET") {
return tagSet, true, true
}
return tagSequence, true, true
case reflect.String:
return tagPrintableString, false, true
}
return 0, false, false
} | |
c181389 | < pad; i++ {
nb[len(raw)+i] = '='
}
}
return lowerBase32.DecodeString(string(nb))
} | |
c181390 | MailNotifier from DB: %v", ctxt, err)
return models.MailNotifier{}, ErrMissingNotifier
} else {
return notifier[0], nil
}
} | |
c181391 | %v", ctxt, notifier.MailId, err)
return errors.New(fmt.Sprintf("Error Updating the mail notifier info for: %s Error: %v", notifier.MailId, err))
}
return nil
} | |
c181392 | logger.Get().Critical("Auth provider %s was registered twice", name)
}
providers[name] = factory
} | |
c181393 | logger.Get().Error("Error Initilaizing User Table", err)
return err
}
return nil
} | |
c181394 | {
defer HandleCrash()
f()
}()
time.Sleep(period)
}
} | |
c181395 | fmt.Sprintf("%v:%v\n", file, line)
}
logger.Get().Error("Recovered from panic: %#v (%v)\n%v", r, r, callers)
} | |
c181396 |
defer m.Close(c)
err := c.Find(bson.M{"username": username}).One(&user)
if err != nil {
return user, ErrMissingUser
}
return user, nil
} | |
c181397 | nil {
logger.Get().Error("Error getting record from DB. error: %v", err)
return us, mkmgoerror(err.Error())
}
return us, nil
} | |
c181398 |
logger.Get().Error("Error deleting record from DB for user: %s. error: %v", user.Username, err)
return mkmgoerror(err.Error())
}
return nil
} | |
c181399 |
err := c.Remove(bson.M{"username": username})
if err != nil {
logger.Get().Error("Error deleting record from DB for user: %s. error: %v", username, err)
return mkmgoerror(err.Error())
}
return err
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.