id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1 value |
|---|---|---|
c173100 | hist.hist.RecordValues(val, n)
hist.rw.Unlock()
m.hm.Unlock()
} | |
c173101 | := m.NewHistogram(metric)
m.hm.Lock()
hist.rw.Lock()
hist.hist.RecordValue(val)
hist.rw.Unlock()
m.hm.Unlock()
} | |
c173102 |
delete(m.histograms, metric)
m.hm.Unlock()
} | |
c173103 | name: metric,
hist: circonusllhist.New(),
}
m.histograms[metric] = hist
return hist
} | |
c173104 | h.hist.RecordValue(v)
h.rw.Unlock()
} | |
c173105 | if check.Status == statusActive {
numActive++
checkID = idx
}
}
if numActive > 1 {
return nil, fmt.Errorf("[ERROR] multiple check bundles match criteria %s", criteria)
}
bundle := (*checkBundles)[checkID]
return &bundle, nil
} | |
c173106 | len(cm.customConfigFields) > 0 {
for fld, val := range cm.customConfigFields {
chkcfg.Config[config.Key(fld)] = val
}
}
//
// use the default config settings if these are NOT set by user configuration
//
if val, ok := chkcfg.Config[config.AsyncMetrics]; !ok || val == "" {
chkcfg.Config[config.AsyncMetrics] = "true"
}
if val, ok := chkcfg.Config[config.Secret]; !ok || val == "" {
chkcfg.Config[config.Secret] = checkSecret
}
checkBundle, err := cm.apih.CreateCheckBundle(chkcfg)
if err != nil {
return nil, nil, err
}
return checkBundle, broker, nil
} | |
c173107 |
hash.Write(x)
return hex.EncodeToString(hash.Sum(nil))[0:16], nil
} | |
c173108 | }
uuid := pathParts[0]
filter := api.SearchFilterType{"f__check_uuid": []string{uuid}}
checks, err := cm.apih.SearchChecks(nil, &filter)
if err != nil {
return nil, err
}
if len(*checks) == 0 {
return nil, fmt.Errorf("[ERROR] No checks found with UUID %s", uuid)
}
numActive := 0
checkID := -1
for idx, check := range *checks {
if check.Active {
numActive++
checkID = idx
}
}
if numActive > 1 {
return nil, fmt.Errorf("[ERROR] Multiple checks with same UUID %s", uuid)
}
check := (*checks)[checkID]
return &check, nil
} | |
c173109 | := cm.initializeTrapURL()
if err == nil {
cm.initializedmu.Lock()
cm.initialized = true
cm.initializedmu.Unlock()
} else {
cm.Log.Printf("[WARN] error initializing trap %s", err.Error())
}
cm.apih.DisableExponentialBackoff()
}()
} | |
c173110 | cm.initializedmu.RUnlock()
return cm.initialized
} | |
c173111 | 1 * time.Second,
ResponseHeaderTimeout: 1 * time.Second,
}
trap.SockTransport.RegisterLocation(service, sockPath)
trap.IsSocket = true
}
if u.Scheme == "https" {
// preference user-supplied TLS configuration
if cm.brokerTLS != nil {
trap.TLS = cm.brokerTLS
return trap, nil
}
// api.circonus.com uses a public CA signed certificate
// trap.noit.circonus.net uses Circonus CA private certificate
// enterprise brokers use private CA certificate
if trap.URL.Hostname() == "api.circonus.com" {
return trap, nil
}
if cm.certPool == nil {
if err := cm.loadCACert(); err != nil {
return nil, errors.Wrap(err, "get submission url")
}
}
t := &tls.Config{
RootCAs: cm.certPool,
}
if cm.trapCN != "" {
t.ServerName = string(cm.trapCN)
}
trap.TLS = t
}
return trap, nil
} | |
c173112 | CA cert (if custom TLS config not supplied)
return cm.initializeTrapURL()
} | |
c173113 | nil
}
if time.Since(cm.trapLastUpdate) >= cm.trapMaxURLAge {
return cm.ResetTrap()
}
return nil
} | |
c173114 |
return nil, err
}
if a.Debug {
a.Log.Printf("[DEBUG] fetch rule set group, received JSON: %s", string(result))
}
rulesetGroup := &RuleSetGroup{}
if err := json.Unmarshal(result, rulesetGroup); err != nil {
return nil, err
}
return rulesetGroup, nil
} | |
c173115 | json.Unmarshal(result, &rulesetGroups); err != nil {
return nil, err
}
return &rulesetGroups, nil
} | |
c173116 | a.Debug {
a.Log.Printf("[DEBUG] update rule set group, sending JSON: %s", string(jsonCfg))
}
result, err := a.Put(groupCID, jsonCfg)
if err != nil {
return nil, err
}
groups := &RuleSetGroup{}
if err := json.Unmarshal(result, groups); err != nil {
return nil, err
}
return groups, nil
} | |
c173117 | string(jsonCfg))
}
result, err := a.Post(config.RuleSetGroupPrefix, jsonCfg)
if err != nil {
return nil, err
}
group := &RuleSetGroup{}
if err := json.Unmarshal(result, group); err != nil {
return nil, err
}
return group, nil
} | |
c173118 | [nil]")
}
return a.DeleteRuleSetGroupByCID(CIDType(&cfg.CID))
} | |
c173119 | if !matched {
return false, fmt.Errorf("Invalid rule set group CID [%s]", groupCID)
}
_, err = a.Delete(groupCID)
if err != nil {
return false, err
}
return true, nil
} | |
c173120 | return nil, err
}
if a.Debug {
a.Log.Printf("[DEBUG] fetch dashboard, received JSON: %s", string(result))
}
dashboard := new(Dashboard)
if err := json.Unmarshal(result, dashboard); err != nil {
return nil, err
}
return dashboard, nil
} | |
c173121 | json.Unmarshal(result, &dashboards); err != nil {
return nil, err
}
return &dashboards, nil
} | |
c173122 |
a.Log.Printf("[DEBUG] update dashboard, sending JSON: %s", string(jsonCfg))
}
result, err := a.Put(dashboardCID, jsonCfg)
if err != nil {
return nil, err
}
dashboard := &Dashboard{}
if err := json.Unmarshal(result, dashboard); err != nil {
return nil, err
}
return dashboard, nil
} | |
c173123 |
result, err := a.Post(config.DashboardPrefix, jsonCfg)
if err != nil {
return nil, err
}
dashboard := &Dashboard{}
if err := json.Unmarshal(result, dashboard); err != nil {
return nil, err
}
return dashboard, nil
} | |
c173124 |
return false, fmt.Errorf("Invalid dashboard config [nil]")
}
return a.DeleteDashboardByCID(CIDType(&cfg.CID))
} | |
c173125 | if !matched {
return false, fmt.Errorf("Invalid dashboard CID [%s]", dashboardCID)
}
_, err = a.Delete(dashboardCID)
if err != nil {
return false, err
}
return true, nil
} | |
c173126 |
m.SetTextValue(metric, val)
} | |
c173127 | val string) {
m.tm.Lock()
defer m.tm.Unlock()
m.text[metric] = val
} | |
c173128 | defer m.tm.Unlock()
delete(m.text, metric)
} | |
c173129 | defer m.tfm.Unlock()
delete(m.textFuncs, metric)
} | |
c173130 | return nil, err
}
if a.Debug {
a.Log.Printf("[DEBUG] fetch alert, received JSON: %s", string(result))
}
alert := &Alert{}
if err := json.Unmarshal(result, alert); err != nil {
return nil, err
}
return alert, nil
} | |
c173131 | json.Unmarshal(result, &alerts); err != nil {
return nil, err
}
return &alerts, nil
} | |
c173132 |
return nil, err
}
if a.Debug {
a.Log.Printf("[DEBUG] fetch rule set, received JSON: %s", string(result))
}
ruleset := &RuleSet{}
if err := json.Unmarshal(result, ruleset); err != nil {
return nil, err
}
return ruleset, nil
} | |
c173133 | json.Unmarshal(result, &rulesets); err != nil {
return nil, err
}
return &rulesets, nil
} | |
c173134 |
a.Log.Printf("[DEBUG] update rule set, sending JSON: %s", string(jsonCfg))
}
result, err := a.Put(rulesetCID, jsonCfg)
if err != nil {
return nil, err
}
ruleset := &RuleSet{}
if err := json.Unmarshal(result, ruleset); err != nil {
return nil, err
}
return ruleset, nil
} | |
c173135 | }
resp, err := a.Post(config.RuleSetPrefix, jsonCfg)
if err != nil {
return nil, err
}
ruleset := &RuleSet{}
if err := json.Unmarshal(resp, ruleset); err != nil {
return nil, err
}
return ruleset, nil
} | |
c173136 |
return false, fmt.Errorf("Invalid rule set config [nil]")
}
return a.DeleteRuleSetByCID(CIDType(&cfg.CID))
} | |
c173137 | if !matched {
return false, fmt.Errorf("Invalid rule set CID [%s]", rulesetCID)
}
_, err = a.Delete(rulesetCID)
if err != nil {
return false, err
}
return true, nil
} | |
c173138 | uint64) {
m.Add(metric, val)
} | |
c173139 |
defer m.cm.Unlock()
m.counters[metric] = val
} | |
c173140 | defer m.cm.Unlock()
delete(m.counters, metric)
} | |
c173141 | defer m.cfm.Unlock()
delete(m.counterFuncs, metric)
} | |
c173142 | "histogram" (aka percentile)
}
case "s":
continue // text metrics unsupported
}
fmt.Fprintf(w, "%s %v %d\n", name, metric.Value, ts)
}
err := w.Flush()
if err != nil {
return nil, errors.Wrap(err, "flushing metric buffer")
}
return &b, err
} | |
c173143 |
if m.Debug {
m.Log.Println("[DEBUG] No metrics to send, skipping")
}
}
m.flushmu.Lock()
m.flushing = false
m.flushmu.Unlock()
} | |
c173144 | return nil, err
}
if a.Debug {
a.Log.Printf("[DEBUG] fetch worksheet, received JSON: %s", string(result))
}
worksheet := new(Worksheet)
if err := json.Unmarshal(result, worksheet); err != nil {
return nil, err
}
return worksheet, nil
} | |
c173145 | json.Unmarshal(result, &worksheets); err != nil {
return nil, err
}
return &worksheets, nil
} | |
c173146 |
a.Log.Printf("[DEBUG] update worksheet, sending JSON: %s", string(jsonCfg))
}
result, err := a.Put(worksheetCID, jsonCfg)
if err != nil {
return nil, err
}
worksheet := &Worksheet{}
if err := json.Unmarshal(result, worksheet); err != nil {
return nil, err
}
return worksheet, nil
} | |
c173147 |
result, err := a.Post(config.WorksheetPrefix, jsonCfg)
if err != nil {
return nil, err
}
worksheet := &Worksheet{}
if err := json.Unmarshal(result, worksheet); err != nil {
return nil, err
}
return worksheet, nil
} | |
c173148 |
return false, fmt.Errorf("Invalid worksheet config [nil]")
}
return a.DeleteWorksheetByCID(CIDType(&cfg.CID))
} | |
c173149 | if !matched {
return false, fmt.Errorf("Invalid worksheet CID [%s]", worksheetCID)
}
_, err = a.Delete(worksheetCID)
if err != nil {
return false, err
}
return true, nil
} | |
c173150 | nil {
return nil, err
}
if a.Debug {
a.Log.Printf("[DEBUG] fetch contact group, received JSON: %s", string(result))
}
group := new(ContactGroup)
if err := json.Unmarshal(result, group); err != nil {
return nil, err
}
return group, nil
} | |
c173151 | if err := json.Unmarshal(result, &groups); err != nil {
return nil, err
}
return &groups, nil
} | |
c173152 | a.Debug {
a.Log.Printf("[DEBUG] update contact group, sending JSON: %s", string(jsonCfg))
}
result, err := a.Put(groupCID, jsonCfg)
if err != nil {
return nil, err
}
group := &ContactGroup{}
if err := json.Unmarshal(result, group); err != nil {
return nil, err
}
return group, nil
} | |
c173153 |
}
result, err := a.Post(config.ContactGroupPrefix, jsonCfg)
if err != nil {
return nil, err
}
group := &ContactGroup{}
if err := json.Unmarshal(result, group); err != nil {
return nil, err
}
return group, nil
} | |
c173154 | [nil]")
}
return a.DeleteContactGroupByCID(CIDType(&cfg.CID))
} | |
c173155 | err
}
if a.Debug {
a.Log.Printf("[DEBUG] fetch broker, received JSON: %s", string(result))
}
response := new(Broker)
if err := json.Unmarshal(result, &response); err != nil {
return nil, err
}
return response, nil
} | |
c173156 |
return nil, err
}
var response []Broker
if err := json.Unmarshal(result, &response); err != nil {
return nil, err
}
return &response, nil
} | |
c173157 | !exists {
return true
}
if !active && cm.forceMetricActivation {
return true
}
return false
} | |
c173158 |
currentTags = tags
tagsUpdated = true
} else {
numNewTags := countNewTags(currentTags, tags)
if numNewTags > 0 {
action = "Set"
currentTags = tags
tagsUpdated = true
}
}
}
if tagsUpdated {
cm.metricTags[metricName] = currentTags
}
if cm.Debug && action != "" {
cm.Log.Printf("[DEBUG] %s metric tag(s) %s %v\n", action, metricName, tags)
}
return tagsUpdated
} | |
c173159 |
}
cm.checkBundle.Metrics = cm.checkBundle.Metrics[0 : numCurrMetrics+numNewMetrics]
i := 0
for _, metric := range newMetrics {
cm.checkBundle.Metrics[numCurrMetrics+i] = *metric
i++
updatedCheckBundle = true
}
if updatedCheckBundle {
cm.forceCheckUpdate = true
}
return updatedCheckBundle
} | |
c173160 | }
cm.availableMetricsmu.Lock()
cm.availableMetrics = availableMetrics
cm.availableMetricsmu.Unlock()
} | |
c173161 | for _, currTag := range currTags {
if newTag == currTag {
found = true
break
}
}
if !found {
newTagCount++
}
}
return newTagCount
} | |
c173162 | if rule.exact {
if word == rule.suffix {
return rule.replacement
}
} else {
if strings.HasSuffix(word, rule.suffix) {
return replaceLast(word, rule.suffix, rule.replacement)
}
}
}
return word + "s"
} | |
c173163 |
if rule.exact {
if word == rule.suffix {
return rule.replacement
}
} else {
if strings.HasSuffix(word, rule.suffix) {
return replaceLast(word, rule.suffix, rule.replacement)
}
}
}
return word
} | |
c173164 | strings.ToUpper(word[:1]) + word[1:]
} | |
c173165 | := splitAtCaseChangeWithTitlecase(word)
return strings.Join(words, "")
} | |
c173166 | alg = jwt.ES384
case 132:
alg = jwt.ES512
default:
return jwt.NONE, fmt.Errorf("invalid key length %d", keyLen)
}
return alg, nil
} | |
c173167 |
case *ecdsa.PublicKey:
return getSuitableAlgFromCurve(k.Curve)
case *rsa.PrivateKey:
return jwt.PS512, nil
case *rsa.PublicKey:
return jwt.PS512, nil
}
}
return jwt.NONE, errors.New("cannot determine key type")
} | |
c173168 | {
val = i
} else if f, err := strconv.ParseFloat(a[1], 64); err == nil {
val = f
} else if b, err := strconv.ParseBool(a[1]); err == nil {
val = b
} else if s, err := strconv.Unquote(a[1]); err == nil {
val = s
} else { // treat as string
val = a[1]
}
m[a[0]] = val
}
return json.Marshal(m)
} | |
c173169 | format output
out, err := json.MarshalIndent(&ut, "", " ")
if err != nil {
return nil, err
}
return out, nil
} | |
c173170 | return nil, err
}
// encode claims
out, err := signer.Encode(&m)
if err != nil {
return nil, err
}
return out, nil
} | |
c173171 |
gsa.transport = transport
return nil
}
} | |
c173172 | return Transport(&http.Transport{
Proxy: http.ProxyURL(u),
})(gsa)
}
} | |
c173173 |
gsa.expiration = expiration
return nil
}
} | |
c173174 | {
return nil, err
}
// add payload
_, err = buf.Write(payloadEnc)
if err != nil {
return nil, err
}
// sign
sig, err := signer.Sign(buf.Bytes())
if err != nil {
return nil, err
}
// add 2nd separator
_, err = buf.Write(tokenSep)
if err != nil {
return nil, err
}
// add sig
_, err = buf.Write(sig)
if err != nil {
return nil, err
}
return buf.Bytes(), nil
} | |
c173175 | return peekField(buf, field, tokenPositionHeader)
} | |
c173176 | alg
err = (&alg).UnmarshalText([]byte(algVal))
if err != nil {
return NONE, err
}
return alg, nil
} | |
c173177 | issuer
issuer, err := PeekPayloadField(buf, "iss")
if err != nil {
return NONE, "", err
}
return alg, issuer, nil
} | |
c173178 | {
if pub, ok = pubRaw.(*ecdsa.PublicKey); !ok {
return nil, ErrInvalidPublicKey
}
}
// check that either a private or public key has been provided
if priv == nil && pub == nil {
return nil, ErrMissingPrivateOrPublicKey
}
return &EccSigner{
alg: alg,
curve: curve,
hash: hash,
priv: priv,
pub: pub,
keyLen: keyLen,
}, nil
}
} | |
c173179 |
// apply opts
for _, o := range opts {
if err = o(b); err != nil {
return nil, fmt.Errorf("jwt/bearer: %v", err)
}
}
return b, nil
} | |
c173180 | &oauth2.Transport{
Source: b,
},
}
} | |
c173181 | ([]byte, error) {
return r.SignFunc(rand, priv, hash, buf)
} | |
c173182 | hashed []byte, sig []byte) error {
return r.VerifyFunc(pub, hash, hashed, sig)
} | |
c173183 | if pub.N.BitLen() < RSAMinimumBitLen {
return nil, ErrInvalidPublicKeySize
}
}
// check that either a private or public key has been provided
if priv == nil && pub == nil {
return nil, ErrMissingPrivateOrPublicKey
}
return &RSASigner{
alg: alg,
method: method,
hash: hash,
priv: priv,
pub: pub,
}, nil
}
} | |
c173184 | := objVal.Type().Field(i)
if tagName == fieldType.Tag.Get("jwt") {
field := objVal.Field(i)
return &field
}
}
return nil
} | |
c173185 | type, if same, set
if fieldVal.Type() == defaultObjValElem.Type() {
fieldVal.Set(defaultObjValElem)
return nil
}
// otherwise, assign obj address of field
obj = fieldVal.Addr().Interface()
}
// decode json
d := json.NewDecoder(bytes.NewBuffer(buf))
d.UseNumber()
return d.Decode(obj)
} | |
c173186 |
headerObj = headerVal.Interface()
}
if headerObj == nil {
headerObj = alg.Header()
}
// get payload
if payloadVal := getFieldWithTag(obj, "payload"); payloadVal != nil {
payloadObj = payloadVal.Interface()
}
if payloadObj == nil {
payloadObj = obj
}
return headerObj, payloadObj, nil
} | |
c173187 | || (objKind == reflect.Ptr && objVal.Elem().Kind() == reflect.Struct) {
return grabEncodeTargets(alg, obj)
}
return alg.Header(), obj, nil
} | |
c173188 | != nil {
return "", fmt.Errorf("could not decode token %s", typ)
}
// json decode
m := make(map[string]interface{})
err = json.Unmarshal(dec, &m)
if err != nil {
return "", err
}
if val, ok := m[fieldName]; ok {
return fmt.Sprintf("%v", val), nil
}
return "", fmt.Errorf("token %s field %s not present or invalid", typ, fieldName)
} | |
c173189 | tok.addExpiration = false
tok.expiresIn = 0
}
return nil
}
} | |
c173190 | add claim to improperly created token")
}
tok.claims[name] = v
return nil
}
} | |
c173191 |
return func(tok *Bearer) error {
tok.transport = transport
return nil
}
} | |
c173192 | ok = keyRaw.([]byte); !ok {
return nil, ErrInvalidPrivateKey
}
return &HmacSigner{
alg: alg,
hash: hash,
key: key,
}, nil
}
} | |
c173193 |
// apply opts
for _, o := range opts {
if err = o(gsa); err != nil {
return nil, err
}
}
return gsa, nil
} | |
c173194 | != nil {
return nil, err
}
return FromJSON(buf, opts...)
} | |
c173195 | nil {
return nil, err
}
return FromJSON(buf, opts...)
} | |
c173196 | %v", err)
}
keyset.AddPublicKeys()
s, err := DefaultAlgorithm.New(keyset)
if err != nil {
return nil, err
}
gsa.signer = s
}
return gsa.signer, nil
} | |
c173197 |
return Encode(alg, signer, obj)
} | |
c173198 |
case "ES512":
*alg = ES512
// rsa-pss
case "PS256":
*alg = PS256
case "PS384":
*alg = PS384
case "PS512":
*alg = PS512
// error
default:
return ErrInvalidAlgorithm
}
return nil
} | |
c173199 |
if len(b) != 3 {
return ErrInvalidToken
}
ut.Header = b[0]
ut.Payload = b[1]
ut.Signature = b[2]
return nil
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.