_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q173000 | Available | validation | func (s *Slave) Available() bool {
return !strings.Contains(s.flags, "disconnected") && !strings.Contains(s.flags, "s_down")
} | go | {
"resource": ""
} |
q173001 | Slaves | validation | func (s *Sentinel) Slaves() ([]*Slave, error) {
res, err := s.doUntilSuccess(func(c redis.Conn) (interface{}, error) {
return queryForSlaves(c, s.MasterName)
})
if err != nil {
return nil, err
}
return res.([]*Slave), nil
} | go | {
"resource": ""
} |
q173002 | SentinelAddrs | validation | func (s *Sentinel) SentinelAddrs() ([]string, error) {
res, err := s.doUntilSuccess(func(c redis.Conn) (interface{}, error) {
return queryForSentinels(c, s.MasterName)
})
if err != nil {
return nil, err
}
return res.([]string), nil
} | go | {
"resource": ""
} |
q173003 | Close | validation | func (s *Sentinel) Close() error {
s.mu.Lock()
s.close()
s.mu.Unlock()
return nil
} | go | {
"resource": ""
} |
q173004 | NewServerList | validation | func NewServerList(servers ...string) (*ServerList, error) {
addrs := make([]*Addr, len(servers))
for i, server := range servers {
if strings.Contains(server, "/") {
addr, err := net.ResolveUnixAddr("unix", server)
if err != nil {
return nil, err
}
addrs[i] = NewAddr(addr)
} else {
tcpaddr, err... | go | {
"resource": ""
} |
q173005 | NewFromServers | validation | func NewFromServers(servers Servers) *Client {
return &Client{
timeout: DefaultTimeout,
maxIdlePerAddr: maxIdleConnsPerAddr,
servers: servers,
freeconn: make(map[string]chan *conn),
bufPool: make(chan []byte, poolSize()),
}
} | go | {
"resource": ""
} |
q173006 | Close | validation | func (c *Client) Close() error {
c.mu.Lock()
defer c.mu.Unlock()
c.closeIdleConns()
c.freeconn = nil
c.maxIdlePerAddr = 0
return nil
} | go | {
"resource": ""
} |
q173007 | Get | validation | func (c *Client) Get(key string) (*Item, error) {
cn, err := c.sendCommand(key, cmdGet, nil, 0, nil)
if err != nil {
return nil, err
}
return c.parseItemResponse(key, cn, true)
} | go | {
"resource": ""
} |
q173008 | GetMulti | validation | func (c *Client) GetMulti(keys []string) (map[string]*Item, error) {
keyMap := make(map[*Addr][]string)
for _, key := range keys {
addr, err := c.servers.PickServer(key)
if err != nil {
return nil, err
}
keyMap[addr] = append(keyMap[addr], key)
}
var chs []chan *Item
for addr, keys := range keyMap {
... | go | {
"resource": ""
} |
q173009 | Set | validation | func (c *Client) Set(item *Item) error {
return c.populateOne(cmdSet, item, 0)
} | go | {
"resource": ""
} |
q173010 | Add | validation | func (c *Client) Add(item *Item) error {
return c.populateOne(cmdAdd, item, 0)
} | go | {
"resource": ""
} |
q173011 | CompareAndSwap | validation | func (c *Client) CompareAndSwap(item *Item) error {
return c.populateOne(cmdSet, item, item.casid)
} | go | {
"resource": ""
} |
q173012 | Delete | validation | func (c *Client) Delete(key string) error {
cn, err := c.sendCommand(key, cmdDelete, nil, 0, nil)
if err != nil {
return err
}
_, _, _, _, err = c.parseResponse(key, cn)
c.condRelease(cn, &err)
return err
} | go | {
"resource": ""
} |
q173013 | Increment | validation | func (c *Client) Increment(key string, delta uint64) (newValue uint64, err error) {
return c.incrDecr(cmdIncr, key, delta)
} | go | {
"resource": ""
} |
q173014 | Flush | validation | func (c *Client) Flush(expiration int) error {
servers, err := c.servers.Servers()
var failed []*Addr
var errs []error
if err != nil {
return err
}
var extras []byte
if expiration > 0 {
extras = make([]byte, 4)
putUint32(extras, uint32(expiration))
}
for _, addr := range servers {
cn, err := c.getConn(... | go | {
"resource": ""
} |
q173015 | ChildClosing | validation | func (pl *processLink) ChildClosing() <-chan struct{} {
// grab a hold of it, and unlock, as .Closing may block.
pl.Lock()
child := pl.child
pl.Unlock()
if child == nil { // already closed? memory optimization.
return closedCh
}
return child.Closing()
} | go | {
"resource": ""
} |
q173016 | OnClosingContext | validation | func OnClosingContext(p goprocess.Process) context.Context {
return &procContext{
done: p.Closing(),
which: closing,
}
} | go | {
"resource": ""
} |
q173017 | OnClosedContext | validation | func OnClosedContext(p goprocess.Process) context.Context {
return &procContext{
done: p.Closed(),
which: closed,
}
} | go | {
"resource": ""
} |
q173018 | LimitChan | validation | func LimitChan(limit int) chan struct{} {
limitch := make(chan struct{}, limit)
for i := 0; i < limit; i++ {
limitch <- struct{}{}
}
return limitch
} | go | {
"resource": ""
} |
q173019 | WithParent | validation | func WithParent(parent Process) Process {
if parent == nil {
panic("nil parent Process")
}
q := newProcess(nil)
parent.AddChild(q)
return q
} | go | {
"resource": ""
} |
q173020 | WithContextAndTeardown | validation | func WithContextAndTeardown(ctx context.Context, tf goprocess.TeardownFunc) goprocess.Process {
p := goprocess.WithTeardown(tf)
CloseAfterContext(p, ctx)
return p
} | go | {
"resource": ""
} |
q173021 | SetTeardown | validation | func (p *process) SetTeardown(tf TeardownFunc) {
if tf == nil {
panic("cannot set nil TeardownFunc")
}
p.Lock()
if p.teardown != nil {
panic("cannot SetTeardown twice")
}
p.teardown = tf
select {
case <-p.Closed():
p.closeErr = tf()
default:
}
p.Unlock()
} | go | {
"resource": ""
} |
q173022 | doClose | validation | func (p *process) doClose() {
// this function is only be called once (protected by p.Lock()).
// and it will panic (on closing channels) otherwise.
close(p.closing) // signal that we're shutting down (Closing)
for len(p.children) > 0 || len(p.waitfors) > 0 {
for plc, _ := range p.children {
child := plc.Chi... | go | {
"resource": ""
} |
q173023 | CloseAfterChildren | validation | func (p *process) CloseAfterChildren() error {
p.Lock()
select {
case <-p.Closed():
p.Unlock()
return p.Close() // get error. safe, after p.Closed()
case <-p.waiting: // already called it.
p.Unlock()
<-p.Closed()
return p.Close() // get error. safe, after p.Closed()
default:
}
p.Unlock()
// here only... | go | {
"resource": ""
} |
q173024 | Ticker | validation | func Ticker(ticker <-chan time.Time, procfunc gp.ProcessFunc) gp.Process {
return gp.Go(callOnTicker(ticker, procfunc))
} | go | {
"resource": ""
} |
q173025 | TickerGo | validation | func TickerGo(ticker <-chan time.Time, procfunc gp.ProcessFunc) gp.Process {
return gp.Go(goCallOnTicker(ticker, procfunc))
} | go | {
"resource": ""
} |
q173026 | Identify | validation | func (c *CustomerIO) Identify(customerID string, attributes map[string]interface{}) error {
j, err := json.Marshal(attributes)
if err != nil {
return err
}
status, responseBody, err := c.request("PUT", c.customerURL(customerID), j)
if err != nil {
return err
} else if status != 200 {
return &CustomerIOEr... | go | {
"resource": ""
} |
q173027 | Track | validation | func (c *CustomerIO) Track(customerID string, eventName string, data map[string]interface{}) error {
body := map[string]interface{}{"name": eventName, "data": data}
j, err := json.Marshal(body)
if err != nil {
return err
}
status, responseBody, err := c.request("POST", c.eventURL(customerID), j)
if err != n... | go | {
"resource": ""
} |
q173028 | TrackAnonymous | validation | func (c *CustomerIO) TrackAnonymous(eventName string, data map[string]interface{}) error {
body := map[string]interface{}{"name": eventName, "data": data}
j, err := json.Marshal(body)
if err != nil {
return err
}
status, responseBody, err := c.request("POST", c.anonURL(), j)
if err != nil {
return err
} e... | go | {
"resource": ""
} |
q173029 | Delete | validation | func (c *CustomerIO) Delete(customerID string) error {
status, responseBody, err := c.request("DELETE", c.customerURL(customerID), []byte{})
if err != nil {
return err
} else if status != 200 {
return &CustomerIOError{status, c.customerURL(customerID), responseBody}
}
return nil
} | go | {
"resource": ""
} |
q173030 | AddDevice | validation | func (c *CustomerIO) AddDevice(customerID string, deviceID string, platform string, data map[string]interface{}) error {
if customerID == "" {
return errors.New("customerID is a required field")
}
if deviceID == "" {
return errors.New("deviceID is a required field")
}
if platform == "" {
return errors.New("p... | go | {
"resource": ""
} |
q173031 | DeleteDevice | validation | func (c *CustomerIO) DeleteDevice(customerID string, deviceID string) error {
status, responseBody, err := c.request("DELETE", c.deleteDeviceURL(customerID, deviceID), []byte{})
if err != nil {
return err
} else if status != 200 {
return &CustomerIOError{status, c.deleteDeviceURL(customerID, deviceID), response... | go | {
"resource": ""
} |
q173032 | initLocales | validation | func initLocales(opt Options) language.Matcher {
tags := make([]language.Tag, len(opt.Langs))
for i, lang := range opt.Langs {
tags[i] = language.Raw.Make(lang)
fname := fmt.Sprintf(opt.Format, lang)
// Append custom locale file.
custom := []interface{}{}
customPath := path.Join(opt.CustomDirectory, fname)
... | go | {
"resource": ""
} |
q173033 | I18n | validation | func I18n(options ...Options) macaron.Handler {
opt := prepareOptions(options)
m := initLocales(opt)
return func(ctx *macaron.Context) {
isNeedRedir := false
hasCookie := false
// 1. Check URL arguments.
lang := ctx.Query(opt.Parameter)
// 2. Get language information from cookies.
if len(lang) == 0 {
... | go | {
"resource": ""
} |
q173034 | FetchCheck | validation | func (a *API) FetchCheck(cid CIDType) (*Check, error) {
if cid == nil || *cid == "" {
return nil, fmt.Errorf("Invalid check CID [none]")
}
checkCID := string(*cid)
matched, err := regexp.MatchString(config.CheckCIDRegex, checkCID)
if err != nil {
return nil, err
}
if !matched {
return nil, fmt.Errorf("In... | go | {
"resource": ""
} |
q173035 | FetchChecks | validation | func (a *API) FetchChecks() (*[]Check, error) {
result, err := a.Get(config.CheckPrefix)
if err != nil {
return nil, err
}
var checks []Check
if err := json.Unmarshal(result, &checks); err != nil {
return nil, err
}
return &checks, nil
} | go | {
"resource": ""
} |
q173036 | New | validation | func New(ac *Config) (*API, error) {
if ac == nil {
return nil, errors.New("Invalid API configuration (nil)")
}
key := TokenKeyType(ac.TokenKey)
if key == "" {
return nil, errors.New("API Token is required")
}
app := TokenAppType(ac.TokenApp)
if app == "" {
app = defaultAPIApp
}
acctID := TokenAccoun... | go | {
"resource": ""
} |
q173037 | Get | validation | func (a *API) Get(reqPath string) ([]byte, error) {
return a.apiRequest("GET", reqPath, nil)
} | go | {
"resource": ""
} |
q173038 | Post | validation | func (a *API) Post(reqPath string, data []byte) ([]byte, error) {
return a.apiRequest("POST", reqPath, data)
} | go | {
"resource": ""
} |
q173039 | apiRequest | validation | func (a *API) apiRequest(reqMethod string, reqPath string, data []byte) ([]byte, error) {
backoffs := []uint{2, 4, 8, 16, 32}
attempts := 0
success := false
var result []byte
var err error
for !success {
result, err = a.apiCall(reqMethod, reqPath, data)
if err == nil {
success = true
}
// break and ... | go | {
"resource": ""
} |
q173040 | FetchGraph | validation | func (a *API) FetchGraph(cid CIDType) (*Graph, error) {
if cid == nil || *cid == "" {
return nil, fmt.Errorf("Invalid graph CID [none]")
}
graphCID := string(*cid)
matched, err := regexp.MatchString(config.GraphCIDRegex, graphCID)
if err != nil {
return nil, err
}
if !matched {
return nil, fmt.Errorf("In... | go | {
"resource": ""
} |
q173041 | FetchGraphs | validation | func (a *API) FetchGraphs() (*[]Graph, error) {
result, err := a.Get(config.GraphPrefix)
if err != nil {
return nil, err
}
var graphs []Graph
if err := json.Unmarshal(result, &graphs); err != nil {
return nil, err
}
return &graphs, nil
} | go | {
"resource": ""
} |
q173042 | UpdateGraph | validation | func (a *API) UpdateGraph(cfg *Graph) (*Graph, error) {
if cfg == nil {
return nil, fmt.Errorf("Invalid graph config [nil]")
}
graphCID := string(cfg.CID)
matched, err := regexp.MatchString(config.GraphCIDRegex, graphCID)
if err != nil {
return nil, err
}
if !matched {
return nil, fmt.Errorf("Invalid gra... | go | {
"resource": ""
} |
q173043 | CreateGraph | validation | func (a *API) CreateGraph(cfg *Graph) (*Graph, error) {
if cfg == nil {
return nil, fmt.Errorf("Invalid graph config [nil]")
}
jsonCfg, err := json.Marshal(cfg)
if err != nil {
return nil, err
}
if a.Debug {
a.Log.Printf("[DEBUG] update graph, sending JSON: %s", string(jsonCfg))
}
result, err := a.Post... | go | {
"resource": ""
} |
q173044 | DeleteGraph | validation | func (a *API) DeleteGraph(cfg *Graph) (bool, error) {
if cfg == nil {
return false, fmt.Errorf("Invalid graph config [nil]")
}
return a.DeleteGraphByCID(CIDType(&cfg.CID))
} | go | {
"resource": ""
} |
q173045 | DeleteGraphByCID | validation | func (a *API) DeleteGraphByCID(cid CIDType) (bool, error) {
if cid == nil || *cid == "" {
return false, fmt.Errorf("Invalid graph CID [none]")
}
graphCID := string(*cid)
matched, err := regexp.MatchString(config.GraphCIDRegex, graphCID)
if err != nil {
return false, err
}
if !matched {
return false, fmt.... | go | {
"resource": ""
} |
q173046 | FetchCheckBundle | validation | func (a *API) FetchCheckBundle(cid CIDType) (*CheckBundle, error) {
if cid == nil || *cid == "" {
return nil, fmt.Errorf("Invalid check bundle CID [none]")
}
bundleCID := string(*cid)
matched, err := regexp.MatchString(config.CheckBundleCIDRegex, bundleCID)
if err != nil {
return nil, err
}
if !matched {
... | go | {
"resource": ""
} |
q173047 | FetchCheckBundles | validation | func (a *API) FetchCheckBundles() (*[]CheckBundle, error) {
result, err := a.Get(config.CheckBundlePrefix)
if err != nil {
return nil, err
}
var checkBundles []CheckBundle
if err := json.Unmarshal(result, &checkBundles); err != nil {
return nil, err
}
return &checkBundles, nil
} | go | {
"resource": ""
} |
q173048 | UpdateCheckBundle | validation | func (a *API) UpdateCheckBundle(cfg *CheckBundle) (*CheckBundle, error) {
if cfg == nil {
return nil, fmt.Errorf("Invalid check bundle config [nil]")
}
bundleCID := string(cfg.CID)
matched, err := regexp.MatchString(config.CheckBundleCIDRegex, bundleCID)
if err != nil {
return nil, err
}
if !matched {
re... | go | {
"resource": ""
} |
q173049 | DeleteCheckBundle | validation | func (a *API) DeleteCheckBundle(cfg *CheckBundle) (bool, error) {
if cfg == nil {
return false, fmt.Errorf("Invalid check bundle config [nil]")
}
return a.DeleteCheckBundleByCID(CIDType(&cfg.CID))
} | go | {
"resource": ""
} |
q173050 | DeleteCheckBundleByCID | validation | func (a *API) DeleteCheckBundleByCID(cid CIDType) (bool, error) {
if cid == nil || *cid == "" {
return false, fmt.Errorf("Invalid check bundle CID [none]")
}
bundleCID := string(*cid)
matched, err := regexp.MatchString(config.CheckBundleCIDRegex, bundleCID)
if err != nil {
return false, err
}
if !matched ... | go | {
"resource": ""
} |
q173051 | Gauge | validation | func (m *CirconusMetrics) Gauge(metric string, val interface{}) {
m.SetGauge(metric, val)
} | go | {
"resource": ""
} |
q173052 | SetGauge | validation | func (m *CirconusMetrics) SetGauge(metric string, val interface{}) {
m.gm.Lock()
defer m.gm.Unlock()
m.gauges[metric] = val
} | go | {
"resource": ""
} |
q173053 | AddGauge | validation | func (m *CirconusMetrics) AddGauge(metric string, val interface{}) {
m.gm.Lock()
defer m.gm.Unlock()
v, ok := m.gauges[metric]
if !ok {
m.gauges[metric] = val
return
}
switch val.(type) {
default:
// ignore it, unsupported type
case int:
m.gauges[metric] = v.(int) + val.(int)
case int8:
m.gauges[me... | go | {
"resource": ""
} |
q173054 | RemoveGauge | validation | func (m *CirconusMetrics) RemoveGauge(metric string) {
m.gm.Lock()
defer m.gm.Unlock()
delete(m.gauges, metric)
} | go | {
"resource": ""
} |
q173055 | RemoveGaugeFunc | validation | func (m *CirconusMetrics) RemoveGaugeFunc(metric string) {
m.gfm.Lock()
defer m.gfm.Unlock()
delete(m.gaugeFuncs, metric)
} | go | {
"resource": ""
} |
q173056 | getGaugeType | validation | func (m *CirconusMetrics) getGaugeType(v interface{}) string {
mt := "n"
switch v.(type) {
case int:
mt = "i"
case int8:
mt = "i"
case int16:
mt = "i"
case int32:
mt = "i"
case uint:
mt = "I"
case uint8:
mt = "I"
case uint16:
mt = "I"
case uint32:
mt = "I"
case int64:
mt = "l"
case uint64:... | go | {
"resource": ""
} |
q173057 | FetchCheckBundleMetrics | validation | func (a *API) FetchCheckBundleMetrics(cid CIDType) (*CheckBundleMetrics, error) {
if cid == nil || *cid == "" {
return nil, fmt.Errorf("Invalid check bundle metrics CID [none]")
}
metricsCID := string(*cid)
matched, err := regexp.MatchString(config.CheckBundleMetricsCIDRegex, metricsCID)
if err != nil {
retu... | go | {
"resource": ""
} |
q173058 | UpdateCheckBundleMetrics | validation | func (a *API) UpdateCheckBundleMetrics(cfg *CheckBundleMetrics) (*CheckBundleMetrics, error) {
if cfg == nil {
return nil, fmt.Errorf("Invalid check bundle metrics config [nil]")
}
metricsCID := string(cfg.CID)
matched, err := regexp.MatchString(config.CheckBundleMetricsCIDRegex, metricsCID)
if err != nil {
... | go | {
"resource": ""
} |
q173059 | getBroker | validation | func (cm *CheckManager) getBroker() (*api.Broker, error) {
if cm.brokerID != 0 {
cid := fmt.Sprintf("/broker/%d", cm.brokerID)
broker, err := cm.apih.FetchBroker(api.CIDType(&cid))
if err != nil {
return nil, err
}
if !cm.isValidBroker(broker) {
return nil, fmt.Errorf(
"[ERROR] designated broker %d... | go | {
"resource": ""
} |
q173060 | getBrokerCN | validation | func (cm *CheckManager) getBrokerCN(broker *api.Broker, submissionURL api.URLType) (string, error) {
u, err := url.Parse(string(submissionURL))
if err != nil {
return "", err
}
hostParts := strings.Split(u.Host, ":")
host := hostParts[0]
if net.ParseIP(host) == nil { // it's a non-ip string
return u.Host, n... | go | {
"resource": ""
} |
q173061 | selectBroker | validation | func (cm *CheckManager) selectBroker() (*api.Broker, error) {
var brokerList *[]api.Broker
var err error
enterpriseType := "enterprise"
if len(cm.brokerSelectTag) > 0 {
filter := api.SearchFilterType{
"f__tags_has": cm.brokerSelectTag,
}
brokerList, err = cm.apih.SearchBrokers(nil, &filter)
if err != ni... | go | {
"resource": ""
} |
q173062 | brokerSupportsCheckType | validation | func (cm *CheckManager) brokerSupportsCheckType(checkType CheckTypeType, details *api.BrokerDetail) bool {
baseType := string(checkType)
for _, module := range details.Modules {
if module == baseType {
return true
}
}
if idx := strings.Index(baseType, ":"); idx > 0 {
baseType = baseType[0:idx]
}
for ... | go | {
"resource": ""
} |
q173063 | FetchMetricCluster | validation | func (a *API) FetchMetricCluster(cid CIDType, extras string) (*MetricCluster, error) {
if cid == nil || *cid == "" {
return nil, fmt.Errorf("Invalid metric cluster CID [none]")
}
clusterCID := string(*cid)
matched, err := regexp.MatchString(config.MetricClusterCIDRegex, clusterCID)
if err != nil {
return nil... | go | {
"resource": ""
} |
q173064 | FetchMetricClusters | validation | func (a *API) FetchMetricClusters(extras string) (*[]MetricCluster, error) {
reqURL := url.URL{
Path: config.MetricClusterPrefix,
}
extra := ""
switch extras {
case "metrics":
extra = "_matching_metrics"
case "uuids":
extra = "_matching_uuid_metrics"
}
if extra != "" {
q := url.Values{}
q.Set("extra... | go | {
"resource": ""
} |
q173065 | UpdateMetricCluster | validation | func (a *API) UpdateMetricCluster(cfg *MetricCluster) (*MetricCluster, error) {
if cfg == nil {
return nil, fmt.Errorf("Invalid metric cluster config [nil]")
}
clusterCID := string(cfg.CID)
matched, err := regexp.MatchString(config.MetricClusterCIDRegex, clusterCID)
if err != nil {
return nil, err
}
if !ma... | go | {
"resource": ""
} |
q173066 | CreateMetricCluster | validation | func (a *API) CreateMetricCluster(cfg *MetricCluster) (*MetricCluster, error) {
if cfg == nil {
return nil, fmt.Errorf("Invalid metric cluster config [nil]")
}
jsonCfg, err := json.Marshal(cfg)
if err != nil {
return nil, err
}
if a.Debug {
a.Log.Printf("[DEBUG] create metric cluster, sending JSON: %s", s... | go | {
"resource": ""
} |
q173067 | DeleteMetricCluster | validation | func (a *API) DeleteMetricCluster(cfg *MetricCluster) (bool, error) {
if cfg == nil {
return false, fmt.Errorf("Invalid metric cluster config [nil]")
}
return a.DeleteMetricClusterByCID(CIDType(&cfg.CID))
} | go | {
"resource": ""
} |
q173068 | DeleteMetricClusterByCID | validation | func (a *API) DeleteMetricClusterByCID(cid CIDType) (bool, error) {
if cid == nil || *cid == "" {
return false, fmt.Errorf("Invalid metric cluster CID [none]")
}
clusterCID := string(*cid)
matched, err := regexp.MatchString(config.MetricClusterCIDRegex, clusterCID)
if err != nil {
return false, err
}
if !m... | go | {
"resource": ""
} |
q173069 | loadCACert | validation | func (cm *CheckManager) loadCACert() error {
if cm.certPool != nil {
return nil
}
cm.certPool = x509.NewCertPool()
var cert []byte
var err error
if cm.enabled {
// only attempt to retrieve broker CA cert if
// the check is being managed.
cert, err = cm.fetchCert()
if err != nil {
return err
}
}... | go | {
"resource": ""
} |
q173070 | fetchCert | validation | func (cm *CheckManager) fetchCert() ([]byte, error) {
if !cm.enabled {
return nil, errors.New("check manager is not enabled")
}
response, err := cm.apih.Get("/pki/ca.crt")
if err != nil {
return nil, err
}
cadata := new(CACert)
if err := json.Unmarshal(response, cadata); err != nil {
return nil, err
}
... | go | {
"resource": ""
} |
q173071 | FetchAccounts | validation | func (a *API) FetchAccounts() (*[]Account, error) {
result, err := a.Get(config.AccountPrefix)
if err != nil {
return nil, err
}
var accounts []Account
if err := json.Unmarshal(result, &accounts); err != nil {
return nil, err
}
return &accounts, nil
} | go | {
"resource": ""
} |
q173072 | UpdateAccount | validation | func (a *API) UpdateAccount(cfg *Account) (*Account, error) {
if cfg == nil {
return nil, fmt.Errorf("Invalid account config [nil]")
}
accountCID := string(cfg.CID)
matched, err := regexp.MatchString(config.AccountCIDRegex, accountCID)
if err != nil {
return nil, err
}
if !matched {
return nil, fmt.Error... | go | {
"resource": ""
} |
q173073 | FetchAnnotation | validation | func (a *API) FetchAnnotation(cid CIDType) (*Annotation, error) {
if cid == nil || *cid == "" {
return nil, fmt.Errorf("Invalid annotation CID [none]")
}
annotationCID := string(*cid)
matched, err := regexp.MatchString(config.AnnotationCIDRegex, annotationCID)
if err != nil {
return nil, err
}
if !matched ... | go | {
"resource": ""
} |
q173074 | FetchAnnotations | validation | func (a *API) FetchAnnotations() (*[]Annotation, error) {
result, err := a.Get(config.AnnotationPrefix)
if err != nil {
return nil, err
}
var annotations []Annotation
if err := json.Unmarshal(result, &annotations); err != nil {
return nil, err
}
return &annotations, nil
} | go | {
"resource": ""
} |
q173075 | UpdateAnnotation | validation | func (a *API) UpdateAnnotation(cfg *Annotation) (*Annotation, error) {
if cfg == nil {
return nil, fmt.Errorf("Invalid annotation config [nil]")
}
annotationCID := string(cfg.CID)
matched, err := regexp.MatchString(config.AnnotationCIDRegex, annotationCID)
if err != nil {
return nil, err
}
if !matched {
... | go | {
"resource": ""
} |
q173076 | CreateAnnotation | validation | func (a *API) CreateAnnotation(cfg *Annotation) (*Annotation, error) {
if cfg == nil {
return nil, fmt.Errorf("Invalid annotation config [nil]")
}
jsonCfg, err := json.Marshal(cfg)
if err != nil {
return nil, err
}
if a.Debug {
a.Log.Printf("[DEBUG] create annotation, sending JSON: %s", string(jsonCfg))
... | go | {
"resource": ""
} |
q173077 | DeleteAnnotation | validation | func (a *API) DeleteAnnotation(cfg *Annotation) (bool, error) {
if cfg == nil {
return false, fmt.Errorf("Invalid annotation config [nil]")
}
return a.DeleteAnnotationByCID(CIDType(&cfg.CID))
} | go | {
"resource": ""
} |
q173078 | DeleteAnnotationByCID | validation | func (a *API) DeleteAnnotationByCID(cid CIDType) (bool, error) {
if cid == nil || *cid == "" {
return false, fmt.Errorf("Invalid annotation CID [none]")
}
annotationCID := string(*cid)
matched, err := regexp.MatchString(config.AnnotationCIDRegex, annotationCID)
if err != nil {
return false, err
}
if !match... | go | {
"resource": ""
} |
q173079 | FetchOutlierReport | validation | func (a *API) FetchOutlierReport(cid CIDType) (*OutlierReport, error) {
if cid == nil || *cid == "" {
return nil, fmt.Errorf("Invalid outlier report CID [none]")
}
reportCID := string(*cid)
matched, err := regexp.MatchString(config.OutlierReportCIDRegex, reportCID)
if err != nil {
return nil, err
}
if !mat... | go | {
"resource": ""
} |
q173080 | FetchOutlierReports | validation | func (a *API) FetchOutlierReports() (*[]OutlierReport, error) {
result, err := a.Get(config.OutlierReportPrefix)
if err != nil {
return nil, err
}
var reports []OutlierReport
if err := json.Unmarshal(result, &reports); err != nil {
return nil, err
}
return &reports, nil
} | go | {
"resource": ""
} |
q173081 | UpdateOutlierReport | validation | func (a *API) UpdateOutlierReport(cfg *OutlierReport) (*OutlierReport, error) {
if cfg == nil {
return nil, fmt.Errorf("Invalid outlier report config [nil]")
}
reportCID := string(cfg.CID)
matched, err := regexp.MatchString(config.OutlierReportCIDRegex, reportCID)
if err != nil {
return nil, err
}
if !matc... | go | {
"resource": ""
} |
q173082 | CreateOutlierReport | validation | func (a *API) CreateOutlierReport(cfg *OutlierReport) (*OutlierReport, error) {
if cfg == nil {
return nil, fmt.Errorf("Invalid outlier report config [nil]")
}
jsonCfg, err := json.Marshal(cfg)
if err != nil {
return nil, err
}
if a.Debug {
a.Log.Printf("[DEBUG] create outlier report, sending JSON: %s", s... | go | {
"resource": ""
} |
q173083 | DeleteOutlierReport | validation | func (a *API) DeleteOutlierReport(cfg *OutlierReport) (bool, error) {
if cfg == nil {
return false, fmt.Errorf("Invalid outlier report config [nil]")
}
return a.DeleteOutlierReportByCID(CIDType(&cfg.CID))
} | go | {
"resource": ""
} |
q173084 | DeleteOutlierReportByCID | validation | func (a *API) DeleteOutlierReportByCID(cid CIDType) (bool, error) {
if cid == nil || *cid == "" {
return false, fmt.Errorf("Invalid outlier report CID [none]")
}
reportCID := string(*cid)
matched, err := regexp.MatchString(config.OutlierReportCIDRegex, reportCID)
if err != nil {
return false, err
}
if !mat... | go | {
"resource": ""
} |
q173085 | FetchUsers | validation | func (a *API) FetchUsers() (*[]User, error) {
result, err := a.Get(config.UserPrefix)
if err != nil {
return nil, err
}
var users []User
if err := json.Unmarshal(result, &users); err != nil {
return nil, err
}
return &users, nil
} | go | {
"resource": ""
} |
q173086 | UpdateUser | validation | func (a *API) UpdateUser(cfg *User) (*User, error) {
if cfg == nil {
return nil, fmt.Errorf("Invalid user config [nil]")
}
userCID := string(cfg.CID)
matched, err := regexp.MatchString(config.UserCIDRegex, userCID)
if err != nil {
return nil, err
}
if !matched {
return nil, fmt.Errorf("Invalid user CID [... | go | {
"resource": ""
} |
q173087 | SetMetricTags | validation | func (m *CirconusMetrics) SetMetricTags(name string, tags []string) bool {
return m.check.AddMetricTags(name, tags, false)
} | go | {
"resource": ""
} |
q173088 | AddMetricTags | validation | func (m *CirconusMetrics) AddMetricTags(name string, tags []string) bool {
return m.check.AddMetricTags(name, tags, true)
} | go | {
"resource": ""
} |
q173089 | FetchMetric | validation | func (a *API) FetchMetric(cid CIDType) (*Metric, error) {
if cid == nil || *cid == "" {
return nil, fmt.Errorf("Invalid metric CID [none]")
}
metricCID := string(*cid)
matched, err := regexp.MatchString(config.MetricCIDRegex, metricCID)
if err != nil {
return nil, err
}
if !matched {
return nil, fmt.Erro... | go | {
"resource": ""
} |
q173090 | FetchMetrics | validation | func (a *API) FetchMetrics() (*[]Metric, error) {
result, err := a.Get(config.MetricPrefix)
if err != nil {
return nil, err
}
var metrics []Metric
if err := json.Unmarshal(result, &metrics); err != nil {
return nil, err
}
return &metrics, nil
} | go | {
"resource": ""
} |
q173091 | UpdateMetric | validation | func (a *API) UpdateMetric(cfg *Metric) (*Metric, error) {
if cfg == nil {
return nil, fmt.Errorf("Invalid metric config [nil]")
}
metricCID := string(cfg.CID)
matched, err := regexp.MatchString(config.MetricCIDRegex, metricCID)
if err != nil {
return nil, err
}
if !matched {
return nil, fmt.Errorf("Inva... | go | {
"resource": ""
} |
q173092 | FetchAcknowledgement | validation | func (a *API) FetchAcknowledgement(cid CIDType) (*Acknowledgement, error) {
if cid == nil || *cid == "" {
return nil, fmt.Errorf("Invalid acknowledgement CID [none]")
}
acknowledgementCID := string(*cid)
matched, err := regexp.MatchString(config.AcknowledgementCIDRegex, acknowledgementCID)
if err != nil {
re... | go | {
"resource": ""
} |
q173093 | FetchAcknowledgements | validation | func (a *API) FetchAcknowledgements() (*[]Acknowledgement, error) {
result, err := a.Get(config.AcknowledgementPrefix)
if err != nil {
return nil, err
}
var acknowledgements []Acknowledgement
if err := json.Unmarshal(result, &acknowledgements); err != nil {
return nil, err
}
return &acknowledgements, nil
} | go | {
"resource": ""
} |
q173094 | UpdateAcknowledgement | validation | func (a *API) UpdateAcknowledgement(cfg *Acknowledgement) (*Acknowledgement, error) {
if cfg == nil {
return nil, fmt.Errorf("Invalid acknowledgement config [nil]")
}
acknowledgementCID := string(cfg.CID)
matched, err := regexp.MatchString(config.AcknowledgementCIDRegex, acknowledgementCID)
if err != nil {
r... | go | {
"resource": ""
} |
q173095 | CreateAcknowledgement | validation | func (a *API) CreateAcknowledgement(cfg *Acknowledgement) (*Acknowledgement, error) {
if cfg == nil {
return nil, fmt.Errorf("Invalid acknowledgement config [nil]")
}
jsonCfg, err := json.Marshal(cfg)
if err != nil {
return nil, err
}
result, err := a.Post(config.AcknowledgementPrefix, jsonCfg)
if err != n... | go | {
"resource": ""
} |
q173096 | Reset | validation | func (m *CirconusMetrics) Reset() {
m.cm.Lock()
defer m.cm.Unlock()
m.cfm.Lock()
defer m.cfm.Unlock()
m.gm.Lock()
defer m.gm.Unlock()
m.gfm.Lock()
defer m.gfm.Unlock()
m.hm.Lock()
defer m.hm.Unlock()
m.tm.Lock()
defer m.tm.Unlock()
m.tfm.Lock()
defer m.tfm.Unlock()
m.counters = make(map[string]uin... | go | {
"resource": ""
} |
q173097 | snapshot | validation | func (m *CirconusMetrics) snapshot() (c map[string]uint64, g map[string]interface{}, h map[string]*circonusllhist.Histogram, t map[string]string) {
c = m.snapCounters()
g = m.snapGauges()
h = m.snapHistograms()
t = m.snapText()
return
} | go | {
"resource": ""
} |
q173098 | Timing | validation | func (m *CirconusMetrics) Timing(metric string, val float64) {
m.SetHistogramValue(metric, val)
} | go | {
"resource": ""
} |
q173099 | RecordValue | validation | func (m *CirconusMetrics) RecordValue(metric string, val float64) {
m.SetHistogramValue(metric, val)
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.