_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q170400 | Logger | validation | func Logger() Handler {
return func(ctx *Context, log *log.Logger) {
start := time.Now()
log.Printf("%s: Started %s %s for %s", time.Now().Format(LogTimeFormat), ctx.Req.Method, ctx.Req.RequestURI, ctx.RemoteAddr())
rw := ctx.Resp.(ResponseWriter)
ctx.Next()
content := fmt.Sprintf("%s: Completed %s %s %v ... | go | {
"resource": ""
} |
q170401 | NewTplFile | validation | func NewTplFile(name string, data []byte, ext string) *TplFile {
return &TplFile{name, data, ext}
} | go | {
"resource": ""
} |
q170402 | NewTemplateFileSystem | validation | func NewTemplateFileSystem(opt RenderOptions, omitData bool) TplFileSystem {
fs := TplFileSystem{}
fs.files = make([]TemplateFile, 0, 10)
// Directories are composed in reverse order because later one overwrites previous ones,
// so once found, we can directly jump out of the loop.
dirs := make([]string, 0, len(o... | go | {
"resource": ""
} |
q170403 | NewTemplateSet | validation | func NewTemplateSet() *TemplateSet {
return &TemplateSet{
sets: make(map[string]*template.Template),
dirs: make(map[string]string),
}
} | go | {
"resource": ""
} |
q170404 | GenerateETag | validation | func GenerateETag(fileSize, fileName, modTime string) string {
etag := fileSize + fileName + modTime
return base64.StdEncoding.EncodeToString([]byte(etag))
} | go | {
"resource": ""
} |
q170405 | Populate | validation | func Populate(values ...interface{}) error {
var g Graph
for _, v := range values {
if err := g.Provide(&Object{Value: v}); err != nil {
return err
}
}
return g.Populate()
} | go | {
"resource": ""
} |
q170406 | String | validation | func (o *Object) String() string {
var buf bytes.Buffer
fmt.Fprint(&buf, o.reflectType)
if o.Name != "" {
fmt.Fprintf(&buf, " named %s", o.Name)
}
return buf.String()
} | go | {
"resource": ""
} |
q170407 | Provide | validation | func (g *Graph) Provide(objects ...*Object) error {
for _, o := range objects {
o.reflectType = reflect.TypeOf(o.Value)
o.reflectValue = reflect.ValueOf(o.Value)
if o.Fields != nil {
return fmt.Errorf(
"fields were specified on object %s when it was provided",
o,
)
}
if o.Name == "" {
if !... | go | {
"resource": ""
} |
q170408 | Populate | validation | func (g *Graph) Populate() error {
for _, o := range g.named {
if o.Complete {
continue
}
if err := g.populateExplicit(o); err != nil {
return err
}
}
// We append and modify our slice as we go along, so we don't use a standard
// range loop, and do a single pass thru each object in our graph.
i :=... | go | {
"resource": ""
} |
q170409 | Objects | validation | func (g *Graph) Objects() []*Object {
objects := make([]*Object, 0, len(g.unnamed)+len(g.named))
for _, o := range g.unnamed {
if !o.embedded {
objects = append(objects, o)
}
}
for _, o := range g.named {
if !o.embedded {
objects = append(objects, o)
}
}
// randomize to prevent callers from relying ... | go | {
"resource": ""
} |
q170410 | newPubSub | validation | func newPubSub(client *pubsub.Client, name string, options *Options, store func(*points.Points)) (*PubSub, error) {
logger := zapwriter.Logger(name)
logger.Info("starting google pubsub receiver",
zap.String("project", options.Project),
zap.String("subscription", options.Subscription),
)
if options.Project == "... | go | {
"resource": ""
} |
q170411 | Stat | validation | func (rcv *PubSub) Stat(send helper.StatCallback) {
messagesReceived := atomic.LoadUint32(&rcv.messagesReceived)
send("messagesReceived", float64(messagesReceived))
metricsReceived := atomic.LoadUint32(&rcv.metricsReceived)
send("metricsReceived", float64(metricsReceived))
errors := atomic.LoadUint32(&rcv.errors... | go | {
"resource": ""
} |
q170412 | New | validation | func New(configFilename string) *App {
app := &App{
ConfigFilename: configFilename,
Config: NewConfig(),
PromRegistry: prometheus.NewPedanticRegistry(),
exit: make(chan bool),
}
return app
} | go | {
"resource": ""
} |
q170413 | configure | validation | func (app *App) configure() error {
var err error
cfg, err := ReadConfig(app.ConfigFilename)
if err != nil {
return err
}
// carbon-cache prefix
if hostname, err := os.Hostname(); err == nil {
hostname = strings.Replace(hostname, ".", "_", -1)
cfg.Common.GraphPrefix = strings.Replace(cfg.Common.GraphPrefi... | go | {
"resource": ""
} |
q170414 | ParseConfig | validation | func (app *App) ParseConfig() error {
app.Lock()
defer app.Unlock()
err := app.configure()
if app.PromRegisterer == nil {
app.PromRegisterer = prometheus.WrapRegistererWith(
prometheus.Labels(app.Config.Prometheus.Labels),
app.PromRegistry,
)
}
return err
} | go | {
"resource": ""
} |
q170415 | ReloadConfig | validation | func (app *App) ReloadConfig() error {
app.Lock()
defer app.Unlock()
var err error
if err = app.configure(); err != nil {
return err
}
runtime.GOMAXPROCS(app.Config.Common.MaxCPU)
app.Cache.SetMaxSize(app.Config.Cache.MaxSize)
app.Cache.SetWriteStrategy(app.Config.Cache.WriteStrategy)
app.Cache.SetTagsEna... | go | {
"resource": ""
} |
q170416 | stopListeners | validation | func (app *App) stopListeners() {
logger := zapwriter.Logger("app")
if app.Api != nil {
app.Api.Stop()
app.Api = nil
logger.Debug("api stopped")
}
if app.CarbonLink != nil {
app.CarbonLink.Stop()
app.CarbonLink = nil
logger.Debug("carbonlink stopped")
}
if app.Carbonserver != nil {
carbonserver :... | go | {
"resource": ""
} |
q170417 | MarshalText | validation | func (o *Offset) MarshalText() ([]byte, error) {
switch *o {
case OffsetNewest:
return []byte("newest"), nil
case OffsetOldest:
return []byte("oldest"), nil
}
return []byte(fmt.Sprintf("%v", *o)), nil
} | go | {
"resource": ""
} |
q170418 | UnmarshalText | validation | func (o *Offset) UnmarshalText(text []byte) error {
offsetName := string(text)
switch strings.ToLower(offsetName) {
case "newest":
*o = OffsetNewest
case "oldest":
*o = OffsetOldest
default:
d, err := time.ParseDuration(offsetName)
if err != nil {
return err
}
*o = Offset(time.Now().Add(d).UnixNano... | go | {
"resource": ""
} |
q170419 | MarshalText | validation | func (p *Protocol) MarshalText() ([]byte, error) {
switch *p {
case ProtocolPlain:
return []byte("plain"), nil
case ProtocolProtobuf:
return []byte("protobuf"), nil
case ProtocolPickle:
return []byte("pickle"), nil
}
return nil, fmt.Errorf("Unsupported offset type %v, supported offsets: %v", p, supportedPro... | go | {
"resource": ""
} |
q170420 | UnmarshalText | validation | func (p *Protocol) UnmarshalText(text []byte) error {
protocolName := string(text)
switch strings.ToLower(protocolName) {
case "plain":
*p = ProtocolPlain
case "protobuf":
*p = ProtocolProtobuf
case "pickle":
*p = ProtocolPickle
default:
return fmt.Errorf("Unsupported protocol type %v, supported: %v", pr... | go | {
"resource": ""
} |
q170421 | UnmarshalText | validation | func (d *Duration) UnmarshalText(text []byte) error {
var err error
d.Duration, err = time.ParseDuration(string(text))
return err
} | go | {
"resource": ""
} |
q170422 | NewOptions | validation | func NewOptions() *Options {
return &Options{
Brokers: []string{"localhost:9092"},
Topic: "graphite",
Partition: 0,
Protocol: ProtocolPlain,
InitialOffset: OffsetOldest,
StateSaveInterval: &Duration{Duration: 60 * time.Second},
ReconnectInterval: &Duration{Durat... | go | {
"resource": ""
} |
q170423 | Stat | validation | func (rcv *Kafka) Stat(send helper.StatCallback) {
metricsReceived := atomic.LoadUint64(&rcv.metricsReceived)
send("metricsReceived", float64(metricsReceived))
errors := atomic.LoadUint64(&rcv.errors)
send("errors", float64(errors))
if !rcv.statsAsCounters {
atomic.AddUint64(&rcv.metricsReceived, -metricsRecei... | go | {
"resource": ""
} |
q170424 | New | validation | func New() *Cache {
c := &Cache{
data: make([]*Shard, shardCount),
writeStrategy: Noop,
}
for i := 0; i < shardCount; i++ {
c.data[i] = &Shard{
items: make(map[string]*points.Points),
notConfirmed: make([]*points.Points, 4),
}
}
settings := cacheSettings{
maxSize: 1000000,
t... | go | {
"resource": ""
} |
q170425 | SetMaxSize | validation | func (c *Cache) SetMaxSize(maxSize uint32) {
s := c.settings.Load().(*cacheSettings)
newSettings := *s
newSettings.maxSize = int32(maxSize)
c.settings.Store(&newSettings)
} | go | {
"resource": ""
} |
q170426 | GetShard | validation | func (c *Cache) GetShard(key string) *Shard {
// @TODO: remove type casts?
return c.data[uint(fnv32(key))%uint(shardCount)]
} | go | {
"resource": ""
} |
q170427 | Add | validation | func (c *Cache) Add(p *points.Points) {
s := c.settings.Load().(*cacheSettings)
if s.xlog != nil {
p.WriteTo(s.xlog)
return
}
if s.tagsEnabled {
var err error
p.Metric, err = tags.Normalize(p.Metric)
if err != nil {
atomic.AddUint32(&c.stat.tagsNormalizeErrors, 1)
return
}
}
// Get map shard.... | go | {
"resource": ""
} |
q170428 | Pop | validation | func (c *Cache) Pop(key string) (p *points.Points, exists bool) {
// Try to get shard.
shard := c.GetShard(key)
shard.Lock()
p, exists = shard.items[key]
delete(shard.items, key)
shard.Unlock()
if exists {
atomic.AddInt32(&c.stat.size, -int32(len(p.Data)))
}
return p, exists
} | go | {
"resource": ""
} |
q170429 | ParseCarbonlinkRequest | validation | func ParseCarbonlinkRequest(d []byte) (*CarbonlinkRequest, error) {
if !(expectBytes(&d, []byte("\x80\x02}")) && pickleMaybeMemo(&d) && expectBytes(&d, []byte("("))) {
return nil, badErr
}
req := NewCarbonlinkRequest()
var Metric, Type string
var ok bool
if expectBytes(&d, []byte("U\x06metric")) {
if !pic... | go | {
"resource": ""
} |
q170430 | NewCarbonlinkListener | validation | func NewCarbonlinkListener(cache *Cache) *CarbonlinkListener {
return &CarbonlinkListener{
cache: cache,
readTimeout: 30 * time.Second,
}
} | go | {
"resource": ""
} |
q170431 | OnePoint | validation | func OnePoint(metric string, value float64, timestamp int64) *Points {
return &Points{
Metric: metric,
Data: []Point{
Point{
Value: value,
Timestamp: timestamp,
},
},
}
} | go | {
"resource": ""
} |
q170432 | NowPoint | validation | func NowPoint(metric string, value float64) *Points {
return OnePoint(metric, value, time.Now().Unix())
} | go | {
"resource": ""
} |
q170433 | Copy | validation | func (p *Points) Copy() *Points {
return &Points{
Metric: p.Metric,
Data: p.Data,
}
} | go | {
"resource": ""
} |
q170434 | ParseText | validation | func ParseText(line string) (*Points, error) {
row := strings.Split(strings.Trim(line, "\n \t\r"), " ")
if len(row) != 3 {
return nil, fmt.Errorf("bad message: %#v", line)
}
// 0x2e == ".". Or use split? @TODO: benchmark
// if strings.Contains(row[0], "..") || row[0][0] == 0x2e || row[0][len(row)-1] == 0x2e {
... | go | {
"resource": ""
} |
q170435 | Eq | validation | func (p *Points) Eq(other *Points) bool {
if other == nil {
return false
}
if p.Metric != other.Metric {
return false
}
if p.Data == nil && other.Data == nil {
return true
}
if (p.Data == nil || other.Data == nil) && (p.Data != nil || other.Data != nil) {
return false
}
if len(p.Data) != len(other.Data... | go | {
"resource": ""
} |
q170436 | Match | validation | func (s WhisperSchemas) Match(metric string) (Schema, bool) {
for _, schema := range s {
if schema.Pattern.MatchString(metric) {
return schema, true
}
}
return Schema{}, false
} | go | {
"resource": ""
} |
q170437 | ParseRetentionDefs | validation | func ParseRetentionDefs(retentionDefs string) (whisper.Retentions, error) {
retentions := make(whisper.Retentions, 0)
for _, retentionDef := range strings.Split(retentionDefs, ",") {
retentionDef = strings.TrimSpace(retentionDef)
parts := strings.Split(retentionDef, ":")
if len(parts) != 2 {
return nil, fmt.... | go | {
"resource": ""
} |
q170438 | RestoreFromFile | validation | func (app *App) RestoreFromFile(filename string, storeFunc func(*points.Points)) error {
var pointsCount int
startTime := time.Now()
logger := zapwriter.Logger("restore").With(zap.String("filename", filename))
logger.Info("restore started")
defer func() {
logger.Info("restore finished",
zap.Int("points", po... | go | {
"resource": ""
} |
q170439 | RestoreFromDir | validation | func (app *App) RestoreFromDir(dumpDir string, storeFunc func(*points.Points)) {
startTime := time.Now()
logger := zapwriter.Logger("restore").With(zap.String("dir", dumpDir))
defer func() {
logger.Info("restore finished",
zap.Duration("runtime", time.Since(startTime)),
)
}()
files, err := ioutil.ReadDir... | go | {
"resource": ""
} |
q170440 | Restore | validation | func (app *App) Restore(storeFunc func(*points.Points), path string, rps int) {
if rps > 0 {
ticker := persister.NewThrottleTicker(rps)
defer ticker.Stop()
throttledStoreFunc := func(p *points.Points) {
for i := 0; i < len(p.Data); i++ {
<-ticker.C
}
storeFunc(p)
}
app.RestoreFromDir(path, thr... | go | {
"resource": ""
} |
q170441 | Root | validation | func Root(t *testing.T, callback func(dir string)) {
tmpDir, err := ioutil.TempDir("", "")
if err != nil {
t.Fatal(err)
}
defer func() {
if err := os.RemoveAll(tmpDir); err != nil {
t.Fatal(err)
}
}()
callback(tmpDir)
} | go | {
"resource": ""
} |
q170442 | delete | validation | func (q *Queue) delete(key []byte) {
err := q.db.Delete([]byte(key), nil)
atomic.AddUint32(&q.stat.deleteCount, 1)
if err != nil {
atomic.AddUint32(&q.stat.deleteErrors, 1)
q.logger.Error("delete from queue database failed", zap.Error(err))
}
} | go | {
"resource": ""
} |
q170443 | NewWhisper | validation | func NewWhisper(
rootPath string,
schemas WhisperSchemas,
aggregation *WhisperAggregation,
recv func(chan bool) string,
pop func(string) (*points.Points, bool),
confirm func(*points.Points)) *Whisper {
return &Whisper{
recv: recv,
pop: pop,
confirm: confirm,
sc... | go | {
"resource": ""
} |
q170444 | NewWhisperAggregation | validation | func NewWhisperAggregation() *WhisperAggregation {
return &WhisperAggregation{
Data: make([]*whisperAggregationItem, 0),
Default: &whisperAggregationItem{
name: "default",
pattern: nil,
xFilesFactor: 0.5,
aggregationMethodStr: "average",
aggregationMethod: whi... | go | {
"resource": ""
} |
q170445 | match | validation | func (a *WhisperAggregation) match(metric string) *whisperAggregationItem {
for _, s := range a.Data {
if s.pattern.MatchString(metric) {
return s
}
}
return a.Default
} | go | {
"resource": ""
} |
q170446 | oldPlain | validation | func oldPlain(body []byte) ([]*points.Points, error) {
result := make([]*points.Points, 4)
reader := bytes.NewBuffer(body)
for {
line, err := reader.ReadBytes('\n')
if err != nil && err != io.EOF {
return result, err
}
if len(line) == 0 {
break
}
if line[len(line)-1] != '\n' {
return result... | go | {
"resource": ""
} |
q170447 | UpdateIntegrationPD | validation | func (client *Client) UpdateIntegrationPD(pdIntegration *IntegrationPDRequest) error {
return client.doJsonRequest("PUT", "/v1/integration/pagerduty", pdIntegration, nil)
} | go | {
"resource": ""
} |
q170448 | GetIntegrationPD | validation | func (client *Client) GetIntegrationPD() (*integrationPD, error) {
var out integrationPD
if err := client.doJsonRequest("GET", "/v1/integration/pagerduty", nil, &out); err != nil {
return nil, err
}
return &out, nil
} | go | {
"resource": ""
} |
q170449 | CreateIntegrationSlack | validation | func (client *Client) CreateIntegrationSlack(slackIntegration *IntegrationSlackRequest) error {
return client.doJsonRequest("POST", "/v1/integration/slack", slackIntegration, nil)
} | go | {
"resource": ""
} |
q170450 | UpdateIntegrationSlack | validation | func (client *Client) UpdateIntegrationSlack(slackIntegration *IntegrationSlackRequest) error {
return client.doJsonRequest("PUT", "/v1/integration/slack", slackIntegration, nil)
} | go | {
"resource": ""
} |
q170451 | GetIntegrationSlack | validation | func (client *Client) GetIntegrationSlack() (*IntegrationSlackRequest, error) {
var out IntegrationSlackRequest
if err := client.doJsonRequest("GET", "/v1/integration/slack", nil, &out); err != nil {
return nil, err
}
return &out, nil
} | go | {
"resource": ""
} |
q170452 | CreateIntegrationAWS | validation | func (client *Client) CreateIntegrationAWS(awsAccount *IntegrationAWSAccount) (*IntegrationAWSAccountCreateResponse, error) {
var out IntegrationAWSAccountCreateResponse
if err := client.doJsonRequest("POST", "/v1/integration/aws", awsAccount, &out); err != nil {
return nil, err
}
return &out, nil
} | go | {
"resource": ""
} |
q170453 | GetIntegrationAWS | validation | func (client *Client) GetIntegrationAWS() (*[]IntegrationAWSAccount, error) {
var response IntegrationAWSAccountGetResponse
if err := client.doJsonRequest("GET", "/v1/integration/aws", nil, &response); err != nil {
return nil, err
}
return &response.Accounts, nil
} | go | {
"resource": ""
} |
q170454 | DeleteIntegrationAWS | validation | func (client *Client) DeleteIntegrationAWS(awsAccount *IntegrationAWSAccountDeleteRequest) error {
return client.doJsonRequest("DELETE", "/v1/integration/aws", awsAccount, nil)
} | go | {
"resource": ""
} |
q170455 | ListIntegrationGCP | validation | func (client *Client) ListIntegrationGCP() ([]*IntegrationGCP, error) {
var list []*IntegrationGCP
if err := client.doJsonRequest("GET", "/v1/integration/gcp", nil, &list); err != nil {
return nil, err
}
return list, nil
} | go | {
"resource": ""
} |
q170456 | CreateIntegrationGCP | validation | func (client *Client) CreateIntegrationGCP(cir *IntegrationGCPCreateRequest) error {
return client.doJsonRequest("POST", "/v1/integration/gcp", cir, nil)
} | go | {
"resource": ""
} |
q170457 | UpdateIntegrationGCP | validation | func (client *Client) UpdateIntegrationGCP(cir *IntegrationGCPUpdateRequest) error {
return client.doJsonRequest("POST", "/v1/integration/gcp/host_filters", cir, nil)
} | go | {
"resource": ""
} |
q170458 | DeleteIntegrationGCP | validation | func (client *Client) DeleteIntegrationGCP(cir *IntegrationGCPDeleteRequest) error {
return client.doJsonRequest("DELETE", "/v1/integration/gcp", cir, nil)
} | go | {
"resource": ""
} |
q170459 | GetDashboardList | validation | func (client *Client) GetDashboardList(id int) (*DashboardList, error) {
var out DashboardList
if err := client.doJsonRequest("GET", fmt.Sprintf("/v1/dashboard/lists/manual/%d", id), nil, &out); err != nil {
return nil, err
}
return &out, nil
} | go | {
"resource": ""
} |
q170460 | GetDashboardLists | validation | func (client *Client) GetDashboardLists() ([]DashboardList, error) {
var out reqGetDashboardLists
if err := client.doJsonRequest("GET", "/v1/dashboard/lists/manual", nil, &out); err != nil {
return nil, err
}
return out.DashboardLists, nil
} | go | {
"resource": ""
} |
q170461 | CreateDashboardList | validation | func (client *Client) CreateDashboardList(list *DashboardList) (*DashboardList, error) {
var out DashboardList
if err := client.doJsonRequest("POST", "/v1/dashboard/lists/manual", list, &out); err != nil {
return nil, err
}
return &out, nil
} | go | {
"resource": ""
} |
q170462 | UpdateDashboardList | validation | func (client *Client) UpdateDashboardList(list *DashboardList) error {
req := reqUpdateDashboardList{list.GetName()}
return client.doJsonRequest("PUT", fmt.Sprintf("/v1/dashboard/lists/manual/%d", *list.Id), req, nil)
} | go | {
"resource": ""
} |
q170463 | GetDashboardListItems | validation | func (client *Client) GetDashboardListItems(id int) ([]DashboardListItem, error) {
var out reqDashboardListItems
if err := client.doJsonRequest("GET", fmt.Sprintf("/v1/dashboard/lists/manual/%d/dashboards", id), nil, &out); err != nil {
return nil, err
}
return out.Dashboards, nil
} | go | {
"resource": ""
} |
q170464 | Snapshot | validation | func (client *Client) Snapshot(query string, start, end time.Time, eventQuery string) (string, error) {
options := map[string]string{"metric_query": query, "event_query": eventQuery}
return client.SnapshotGeneric(options, start, end)
} | go | {
"resource": ""
} |
q170465 | SearchHosts | validation | func (client *Client) SearchHosts(search string) ([]string, error) {
var out reqSearch
if err := client.doJsonRequest("GET", "/v1/search?q=hosts:"+search, nil, &out); err != nil {
return nil, err
}
return out.Results.Hosts, nil
} | go | {
"resource": ""
} |
q170466 | SearchMetrics | validation | func (client *Client) SearchMetrics(search string) ([]string, error) {
var out reqSearch
if err := client.doJsonRequest("GET", "/v1/search?q=metrics:"+search, nil, &out); err != nil {
return nil, err
}
return out.Results.Metrics, nil
} | go | {
"resource": ""
} |
q170467 | CreateAlert | validation | func (client *Client) CreateAlert(alert *Alert) (*Alert, error) {
var out Alert
if err := client.doJsonRequest("POST", "/v1/alert", alert, &out); err != nil {
return nil, err
}
return &out, nil
} | go | {
"resource": ""
} |
q170468 | UpdateAlert | validation | func (client *Client) UpdateAlert(alert *Alert) error {
return client.doJsonRequest("PUT", fmt.Sprintf("/v1/alert/%d", alert.Id),
alert, nil)
} | go | {
"resource": ""
} |
q170469 | GetAlert | validation | func (client *Client) GetAlert(id int) (*Alert, error) {
var out Alert
if err := client.doJsonRequest("GET", fmt.Sprintf("/v1/alert/%d", id), nil, &out); err != nil {
return nil, err
}
return &out, nil
} | go | {
"resource": ""
} |
q170470 | GetAlerts | validation | func (client *Client) GetAlerts() ([]Alert, error) {
var out reqAlerts
if err := client.doJsonRequest("GET", "/v1/alert", nil, &out); err != nil {
return nil, err
}
return out.Alerts, nil
} | go | {
"resource": ""
} |
q170471 | CreateComment | validation | func (client *Client) CreateComment(handle, message string) (*Comment, error) {
var out reqComment
comment := Comment{Message: String(message)}
if len(handle) > 0 {
comment.Handle = String(handle)
}
if err := client.doJsonRequest("POST", "/v1/comments", &comment, &out); err != nil {
return nil, err
}
return ... | go | {
"resource": ""
} |
q170472 | CreateRelatedComment | validation | func (client *Client) CreateRelatedComment(handle, message string,
relid int) (*Comment, error) {
var out reqComment
comment := Comment{Message: String(message), RelatedId: Int(relid)}
if len(handle) > 0 {
comment.Handle = String(handle)
}
if err := client.doJsonRequest("POST", "/v1/comments", &comment, &out); ... | go | {
"resource": ""
} |
q170473 | EditComment | validation | func (client *Client) EditComment(id int, handle, message string) error {
comment := Comment{Message: String(message)}
if len(handle) > 0 {
comment.Handle = String(handle)
}
return client.doJsonRequest("PUT", fmt.Sprintf("/v1/comments/%d", id),
&comment, nil)
} | go | {
"resource": ""
} |
q170474 | CreateMonitor | validation | func (client *Client) CreateMonitor(monitor *Monitor) (*Monitor, error) {
var out Monitor
// TODO: is this more pretty of frowned upon?
if err := client.doJsonRequest("POST", "/v1/monitor", monitor, &out); err != nil {
return nil, err
}
return &out, nil
} | go | {
"resource": ""
} |
q170475 | UpdateMonitor | validation | func (client *Client) UpdateMonitor(monitor *Monitor) error {
return client.doJsonRequest("PUT", fmt.Sprintf("/v1/monitor/%d", *monitor.Id),
monitor, nil)
} | go | {
"resource": ""
} |
q170476 | GetMonitor | validation | func (client *Client) GetMonitor(id int) (*Monitor, error) {
var out Monitor
if err := client.doJsonRequest("GET", fmt.Sprintf("/v1/monitor/%d", id), nil, &out); err != nil {
return nil, err
}
return &out, nil
} | go | {
"resource": ""
} |
q170477 | GetMonitorsByName | validation | func (self *Client) GetMonitorsByName(name string) ([]Monitor, error) {
var out reqMonitors
query, err := url.ParseQuery(fmt.Sprintf("name=%v", name))
if err != nil {
return nil, err
}
err = self.doJsonRequest("GET", fmt.Sprintf("/v1/monitor?%v", query.Encode()), nil, &out.Monitors)
if err != nil {
return ni... | go | {
"resource": ""
} |
q170478 | GetMonitorsByTags | validation | func (self *Client) GetMonitorsByTags(tags []string) ([]Monitor, error) {
var out reqMonitors
query, err := url.ParseQuery(fmt.Sprintf("monitor_tags=%v", strings.Join(tags, ",")))
if err != nil {
return nil, err
}
err = self.doJsonRequest("GET", fmt.Sprintf("/v1/monitor?%v", query.Encode()), nil, &out.Monitors)... | go | {
"resource": ""
} |
q170479 | GetMonitors | validation | func (client *Client) GetMonitors() ([]Monitor, error) {
var out reqMonitors
if err := client.doJsonRequest("GET", "/v1/monitor", nil, &out.Monitors); err != nil {
return nil, err
}
return out.Monitors, nil
} | go | {
"resource": ""
} |
q170480 | GetSyntheticsLocations | validation | func (client *Client) GetSyntheticsLocations() ([]SyntheticsLocation, error) {
var out struct {
Locations []SyntheticsLocation `json:"locations,omitempty"`
}
if err := client.doJsonRequest("GET", "/v1/synthetics/locations", nil, &out); err != nil {
return nil, err
}
return out.Locations, nil
} | go | {
"resource": ""
} |
q170481 | GetBool | validation | func GetBool(v *bool) (bool, bool) {
if v != nil {
return *v, true
}
return false, false
} | go | {
"resource": ""
} |
q170482 | GetIntOk | validation | func GetIntOk(v *int) (int, bool) {
if v != nil {
return *v, true
}
return 0, false
} | go | {
"resource": ""
} |
q170483 | GetStringOk | validation | func GetStringOk(v *string) (string, bool) {
if v != nil {
return *v, true
}
return "", false
} | go | {
"resource": ""
} |
q170484 | GetJsonNumberOk | validation | func GetJsonNumberOk(v *json.Number) (json.Number, bool) {
if v != nil {
return *v, true
}
return "", false
} | go | {
"resource": ""
} |
q170485 | GetPrecision | validation | func GetPrecision(v *PrecisionT) (PrecisionT, bool) {
if v != nil {
return *v, true
}
return PrecisionT(""), false
} | go | {
"resource": ""
} |
q170486 | GetStringId | validation | func GetStringId(id interface{}) (string, error) {
switch v := id.(type) {
case int:
return strconv.Itoa(v), nil
case string:
return v, nil
default:
return "", errors.New("unsupported id type")
}
} | go | {
"resource": ""
} |
q170487 | GetDashboard | validation | func (client *Client) GetDashboard(id interface{}) (*Dashboard, error) {
stringId, err := GetStringId(id)
if err != nil {
return nil, err
}
var out reqGetDashboard
if err := client.doJsonRequest("GET", fmt.Sprintf("/v1/dash/%s", stringId), nil, &out); err != nil {
return nil, err
}
return out.Dashboard, ni... | go | {
"resource": ""
} |
q170488 | GetDashboards | validation | func (client *Client) GetDashboards() ([]DashboardLite, error) {
var out reqGetDashboards
if err := client.doJsonRequest("GET", "/v1/dash", nil, &out); err != nil {
return nil, err
}
return out.Dashboards, nil
} | go | {
"resource": ""
} |
q170489 | CreateDashboard | validation | func (client *Client) CreateDashboard(dash *Dashboard) (*Dashboard, error) {
var out reqGetDashboard
if err := client.doJsonRequest("POST", "/v1/dash", dash, &out); err != nil {
return nil, err
}
return out.Dashboard, nil
} | go | {
"resource": ""
} |
q170490 | UpdateDashboard | validation | func (client *Client) UpdateDashboard(dash *Dashboard) error {
return client.doJsonRequest("PUT", fmt.Sprintf("/v1/dash/%d", *dash.Id),
dash, nil)
} | go | {
"resource": ""
} |
q170491 | InviteUsers | validation | func (client *Client) InviteUsers(emails []string) error {
return client.doJsonRequest("POST", "/v1/invite_users",
reqInviteUsers{Emails: emails}, nil)
} | go | {
"resource": ""
} |
q170492 | CreateUser | validation | func (self *Client) CreateUser(handle, name *string) (*User, error) {
in := struct {
Handle *string `json:"handle"`
Name *string `json:"name"`
}{
Handle: handle,
Name: name,
}
out := struct {
*User `json:"user"`
}{}
if err := self.doJsonRequest("POST", "/v1/user", in, &out); err != nil {
return n... | go | {
"resource": ""
} |
q170493 | GetUsers | validation | func (client *Client) GetUsers() (users []User, err error) {
var udata usersData
uri := "/v1/user"
err = client.doJsonRequest("GET", uri, nil, &udata)
users = udata.Users
return
} | go | {
"resource": ""
} |
q170494 | GetUser | validation | func (client *Client) GetUser(handle string) (user User, err error) {
var udata userData
uri := "/v1/user/" + handle
err = client.doJsonRequest("GET", uri, nil, &udata)
user = udata.User
return
} | go | {
"resource": ""
} |
q170495 | UpdateUser | validation | func (client *Client) UpdateUser(user User) error {
uri := "/v1/user/" + *user.Handle
return client.doJsonRequest("PUT", uri, user, nil)
} | go | {
"resource": ""
} |
q170496 | DeleteUser | validation | func (client *Client) DeleteUser(handle string) error {
uri := "/v1/user/" + handle
return client.doJsonRequest("DELETE", uri, nil, nil)
} | go | {
"resource": ""
} |
q170497 | GetBoard | validation | func (client *Client) GetBoard(id string) (*Board, error) {
var board Board
if err := client.doJsonRequest("GET", fmt.Sprintf("/v1/dashboard/%s", id), nil, &board); err != nil {
return nil, err
}
return &board, nil
} | go | {
"resource": ""
} |
q170498 | DeleteBoard | validation | func (client *Client) DeleteBoard(id string) error {
return client.doJsonRequest("DELETE", fmt.Sprintf("/v1/dashboard/%s", id), nil, nil)
} | go | {
"resource": ""
} |
q170499 | CreateBoard | validation | func (client *Client) CreateBoard(board *Board) (*Board, error) {
var createdBoard Board
if err := client.doJsonRequest("POST", "/v1/dashboard", board, &createdBoard); err != nil {
return nil, err
}
return &createdBoard, nil
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.