_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q6300 | cacheNode | train | func (ndb *nodeDB) cacheNode(node *Node) {
elem := ndb.nodeCacheQueue.PushBack(node)
ndb.nodeCache[string(node.hash)] = elem
if ndb.nodeCacheQueue.Len() > ndb.nodeCacheSize {
oldest := ndb.nodeCacheQueue.Front()
hash := ndb.nodeCacheQueue.Remove(oldest).(*Node).hash
delete(ndb.nodeCache, string(hash))
}
} | go | {
"resource": ""
} |
q6301 | Commit | train | func (ndb *nodeDB) Commit() {
ndb.mtx.Lock()
defer ndb.mtx.Unlock()
ndb.batch.Write()
ndb.batch.Close()
ndb.batch = ndb.db.NewBatch()
} | go | {
"resource": ""
} |
q6302 | SaveRoot | train | func (ndb *nodeDB) SaveRoot(root *Node, version int64) error {
if len(root.hash) == 0 {
panic("Hash should not be empty")
}
return ndb.saveRoot(root.hash, version)
} | go | {
"resource": ""
} |
q6303 | SaveEmptyRoot | train | func (ndb *nodeDB) SaveEmptyRoot(version int64) error {
return ndb.saveRoot([]byte{}, version)
} | go | {
"resource": ""
} |
q6304 | Find | train | func Find(top *html.Node, expr string) []*html.Node {
exp, err := xpath.Compile(expr)
if err != nil {
panic(err)
}
var elems []*html.Node
t := exp.Select(CreateXPathNavigator(top))
for t.MoveNext() {
nav := t.Current().(*NodeNavigator)
n := getCurrentNode(nav)
// avoid adding duplicate nodes.
if len(ele... | go | {
"resource": ""
} |
q6305 | LoadURL | train | func LoadURL(url string) (*html.Node, error) {
resp, err := http.Get(url)
if err != nil {
return nil, err
}
defer resp.Body.Close()
r, err := charset.NewReader(resp.Body, resp.Header.Get("Content-Type"))
if err != nil {
return nil, err
}
return html.Parse(r)
} | go | {
"resource": ""
} |
q6306 | Parse | train | func Parse(r io.Reader) (*html.Node, error) {
return html.Parse(r)
} | go | {
"resource": ""
} |
q6307 | InnerText | train | func InnerText(n *html.Node) string {
var output func(*bytes.Buffer, *html.Node)
output = func(buf *bytes.Buffer, n *html.Node) {
switch n.Type {
case html.TextNode:
buf.WriteString(n.Data)
return
case html.CommentNode:
return
}
for child := n.FirstChild; child != nil; child = child.NextSibling {
... | go | {
"resource": ""
} |
q6308 | OutputHTML | train | func OutputHTML(n *html.Node, self bool) string {
var buf bytes.Buffer
if self {
html.Render(&buf, n)
} else {
for n := n.FirstChild; n != nil; n = n.NextSibling {
html.Render(&buf, n)
}
}
return buf.String()
} | go | {
"resource": ""
} |
q6309 | GetOrganization | train | func (c *Client) GetOrganization(orgID string, args Arguments) (organization *Organization, err error) {
path := fmt.Sprintf("organizations/%s", orgID)
err = c.Get(path, args, &organization)
if organization != nil {
organization.client = c
}
return
} | go | {
"resource": ""
} |
q6310 | GetToken | train | func (c *Client) GetToken(tokenID string, args Arguments) (token *Token, err error) {
path := fmt.Sprintf("tokens/%s", tokenID)
err = c.Get(path, args, &token)
if token != nil {
token.client = c
}
return
} | go | {
"resource": ""
} |
q6311 | FirstCardCreateAction | train | func (c ActionCollection) FirstCardCreateAction() *Action {
sort.Sort(c)
for _, action := range c {
if action.DidCreateCard() {
return action
}
}
return nil
} | go | {
"resource": ""
} |
q6312 | FilterToCardCreationActions | train | func (c ActionCollection) FilterToCardCreationActions() ActionCollection {
newSlice := make(ActionCollection, 0, len(c))
for _, action := range c {
if action.DidCreateCard() {
newSlice = append(newSlice, action)
}
}
return newSlice
} | go | {
"resource": ""
} |
q6313 | FilterToListChangeActions | train | func (c ActionCollection) FilterToListChangeActions() ActionCollection {
newSlice := make(ActionCollection, 0, len(c))
for _, action := range c {
if action.DidChangeListForCard() {
newSlice = append(newSlice, action)
}
}
return newSlice
} | go | {
"resource": ""
} |
q6314 | FilterToCardMembershipChangeActions | train | func (c ActionCollection) FilterToCardMembershipChangeActions() ActionCollection {
newSlice := make(ActionCollection, 0, len(c))
for _, action := range c {
if action.DidChangeCardMembership() || action.DidArchiveCard() || action.DidUnarchiveCard() {
newSlice = append(newSlice, action)
}
}
return newSlice
} | go | {
"resource": ""
} |
q6315 | GetMember | train | func (c *Client) GetMember(memberID string, args Arguments) (member *Member, err error) {
path := fmt.Sprintf("members/%s", memberID)
err = c.Get(path, args, &member)
if err == nil {
member.client = c
}
return
} | go | {
"resource": ""
} |
q6316 | GetMembers | train | func (o *Organization) GetMembers(args Arguments) (members []*Member, err error) {
path := fmt.Sprintf("organizations/%s/members", o.ID)
err = o.client.Get(path, args, &members)
for i := range members {
members[i].client = o.client
}
return
} | go | {
"resource": ""
} |
q6317 | GetMembers | train | func (b *Board) GetMembers(args Arguments) (members []*Member, err error) {
path := fmt.Sprintf("boards/%s/members", b.ID)
err = b.client.Get(path, args, &members)
for i := range members {
members[i].client = b.client
}
return
} | go | {
"resource": ""
} |
q6318 | GetMembers | train | func (c *Card) GetMembers(args Arguments) (members []*Member, err error) {
path := fmt.Sprintf("cards/%s/members", c.ID)
err = c.client.Get(path, args, &members)
for i := range members {
members[i].client = c.client
}
return
} | go | {
"resource": ""
} |
q6319 | GetCustomField | train | func (c *Client) GetCustomField(fieldID string, args Arguments) (customField *CustomField, err error) {
path := fmt.Sprintf("customFields/%s", fieldID)
err = c.Get(path, args, &customField)
return
} | go | {
"resource": ""
} |
q6320 | GetCustomFields | train | func (b *Board) GetCustomFields(args Arguments) (customFields []*CustomField, err error) {
path := fmt.Sprintf("boards/%s/customFields", b.ID)
err = b.client.Get(path, args, &customFields)
return
} | go | {
"resource": ""
} |
q6321 | Less | train | func (durs ByFirstEntered) Less(i, j int) bool {
return durs[i].FirstEntered.Before(durs[j].FirstEntered)
} | go | {
"resource": ""
} |
q6322 | GetMemberDurations | train | func (c *Card) GetMemberDurations() (durations []*MemberDuration, err error) {
var actions ActionCollection
if len(c.Actions) == 0 {
c.client.log("[trello] GetMemberDurations() called on card '%s' without any Card.Actions. Fetching fresh.", c.ID)
actions, err = c.GetMembershipChangeActions()
if err != nil {
... | go | {
"resource": ""
} |
q6323 | NewBoard | train | func NewBoard(name string) Board {
b := Board{Name: name}
// default values in line with API POST
b.Prefs.SelfJoin = true
b.Prefs.CardCovers = true
return b
} | go | {
"resource": ""
} |
q6324 | CreatedAt | train | func (b *Board) CreatedAt() time.Time {
t, _ := IDToTime(b.ID)
return t
} | go | {
"resource": ""
} |
q6325 | Delete | train | func (b *Board) Delete(extraArgs Arguments) error {
path := fmt.Sprintf("boards/%s", b.ID)
return b.client.Delete(path, Arguments{}, b)
} | go | {
"resource": ""
} |
q6326 | GetBoard | train | func (c *Client) GetBoard(boardID string, args Arguments) (board *Board, err error) {
path := fmt.Sprintf("boards/%s", boardID)
err = c.Get(path, args, &board)
if board != nil {
board.client = c
}
return
} | go | {
"resource": ""
} |
q6327 | GetMyBoards | train | func (c *Client) GetMyBoards(args Arguments) (boards []*Board, err error) {
path := "members/me/boards"
err = c.Get(path, args, &boards)
for i := range boards {
boards[i].client = c
}
return
} | go | {
"resource": ""
} |
q6328 | GetBoards | train | func (m *Member) GetBoards(args Arguments) (boards []*Board, err error) {
path := fmt.Sprintf("members/%s/boards", m.ID)
err = m.client.Get(path, args, &boards)
for i := range boards {
boards[i].client = m.client
}
return
} | go | {
"resource": ""
} |
q6329 | NewClient | train | func NewClient(key, token string) *Client {
return &Client{
Client: http.DefaultClient,
BaseURL: DefaultBaseURL,
Key: key,
Token: token,
throttle: time.Tick(time.Second / 8), // Actually 10/second, but we're extra cautious
testMode: false,
ctx: context.Background(),
}
} | go | {
"resource": ""
} |
q6330 | WithContext | train | func (c *Client) WithContext(ctx context.Context) *Client {
newC := *c
newC.ctx = ctx
return &newC
} | go | {
"resource": ""
} |
q6331 | GetMyNotifications | train | func (c *Client) GetMyNotifications(args Arguments) (notifications []*Notification, err error) {
path := "members/me/notifications"
err = c.Get(path, args, ¬ifications)
for i := range notifications {
notifications[i].client = c
}
return
} | go | {
"resource": ""
} |
q6332 | CreateWebhook | train | func (c *Client) CreateWebhook(webhook *Webhook) error {
path := "webhooks"
args := Arguments{"idModel": webhook.IDModel, "description": webhook.Description, "callbackURL": webhook.CallbackURL}
err := c.Post(path, args, webhook)
if err == nil {
webhook.client = c
}
return err
} | go | {
"resource": ""
} |
q6333 | GetWebhook | train | func (c *Client) GetWebhook(webhookID string, args Arguments) (webhook *Webhook, err error) {
path := fmt.Sprintf("webhooks/%s", webhookID)
err = c.Get(path, args, &webhook)
if webhook != nil {
webhook.client = c
}
return
} | go | {
"resource": ""
} |
q6334 | GetWebhooks | train | func (t *Token) GetWebhooks(args Arguments) (webhooks []*Webhook, err error) {
path := fmt.Sprintf("tokens/%s/webhooks", t.ID)
err = t.client.Get(path, args, &webhooks)
return
} | go | {
"resource": ""
} |
q6335 | GetBoardWebhookRequest | train | func GetBoardWebhookRequest(r *http.Request) (whr *BoardWebhookRequest, err error) {
if r.Method == "HEAD" {
return &BoardWebhookRequest{}, nil
}
decoder := json.NewDecoder(r.Body)
err = decoder.Decode(&whr)
if err != nil {
err = errors.Wrapf(err, "GetBoardWebhookRequest() failed to decode '%s'.", r.URL)
}
r... | go | {
"resource": ""
} |
q6336 | CreatedAt | train | func (c *Card) CreatedAt() time.Time {
t, _ := IDToTime(c.ID)
return t
} | go | {
"resource": ""
} |
q6337 | CustomFields | train | func (c *Card) CustomFields(boardCustomFields []*CustomField) map[string]interface{} {
cfm := c.customFieldMap
if cfm == nil {
cfm = &(map[string]interface{}{})
// bcfOptionNames[CustomField ID] = Custom Field Name
bcfOptionNames := map[string]string{}
// bcfOptionsMap[CustomField ID][ID of the option] = ... | go | {
"resource": ""
} |
q6338 | MoveToList | train | func (c *Card) MoveToList(listID string, args Arguments) error {
path := fmt.Sprintf("cards/%s", c.ID)
args["idList"] = listID
return c.client.Put(path, args, &c)
} | go | {
"resource": ""
} |
q6339 | SetPos | train | func (c *Card) SetPos(newPos float64) error {
path := fmt.Sprintf("cards/%s", c.ID)
return c.client.Put(path, Arguments{"pos": fmt.Sprintf("%f", newPos)}, c)
} | go | {
"resource": ""
} |
q6340 | RemoveMember | train | func (c *Card) RemoveMember(memberID string) error {
path := fmt.Sprintf("cards/%s/idMembers/%s", c.ID, memberID)
return c.client.Delete(path, Defaults(), nil)
} | go | {
"resource": ""
} |
q6341 | AddMemberID | train | func (c *Card) AddMemberID(memberID string) (member []*Member, err error) {
path := fmt.Sprintf("cards/%s/idMembers", c.ID)
err = c.client.Post(path, Arguments{"value": memberID}, &member)
return member, err
} | go | {
"resource": ""
} |
q6342 | RemoveIDLabel | train | func (c *Card) RemoveIDLabel(labelID string, label *Label) error {
path := fmt.Sprintf("cards/%s/idLabels/%s", c.ID, labelID)
return c.client.Delete(path, Defaults(), label)
} | go | {
"resource": ""
} |
q6343 | AddIDLabel | train | func (c *Card) AddIDLabel(labelID string) error {
path := fmt.Sprintf("cards/%s/idLabels", c.ID)
err := c.client.Post(path, Arguments{"value": labelID}, &c.IDLabels)
return err
} | go | {
"resource": ""
} |
q6344 | MoveToTopOfList | train | func (c *Card) MoveToTopOfList() error {
path := fmt.Sprintf("cards/%s", c.ID)
return c.client.Put(path, Arguments{"pos": "top"}, c)
} | go | {
"resource": ""
} |
q6345 | Update | train | func (c *Card) Update(args Arguments) error {
path := fmt.Sprintf("cards/%s", c.ID)
return c.client.Put(path, args, c)
} | go | {
"resource": ""
} |
q6346 | CreateCard | train | func (c *Client) CreateCard(card *Card, extraArgs Arguments) error {
path := "cards"
args := Arguments{
"name": card.Name,
"desc": card.Desc,
"pos": strconv.FormatFloat(card.Pos, 'g', -1, 64),
"idList": card.IDList,
"idMembers": strings.Join(card.IDMembers, ","),
"idLabels": strings.Jo... | go | {
"resource": ""
} |
q6347 | AddCard | train | func (l *List) AddCard(card *Card, extraArgs Arguments) error {
path := fmt.Sprintf("lists/%s/cards", l.ID)
args := Arguments{
"name": card.Name,
"desc": card.Desc,
"idMembers": strings.Join(card.IDMembers, ","),
"idLabels": strings.Join(card.IDLabels, ","),
}
if card.Due != nil {
args["due"] =... | go | {
"resource": ""
} |
q6348 | AddComment | train | func (c *Card) AddComment(comment string, args Arguments) (*Action, error) {
path := fmt.Sprintf("cards/%s/actions/comments", c.ID)
args["text"] = comment
action := Action{}
err := c.client.Post(path, args, &action)
if err != nil {
err = errors.Wrapf(err, "Error commenting on card %s", c.ID)
}
return &action, ... | go | {
"resource": ""
} |
q6349 | AddURLAttachment | train | func (c *Card) AddURLAttachment(attachment *Attachment) error {
path := fmt.Sprintf("cards/%s/attachments", c.ID)
args := Arguments{
"url": attachment.URL,
"name": attachment.Name,
}
err := c.client.Post(path, args, &attachment)
if err != nil {
err = errors.Wrapf(err, "Error adding attachment to card %s", c... | go | {
"resource": ""
} |
q6350 | GetParentCard | train | func (c *Card) GetParentCard(args Arguments) (*Card, error) {
// Hopefully the card came pre-loaded with Actions including the card creation
action := c.Actions.FirstCardCreateAction()
if action == nil {
// No luck. Go get copyCard actions for this card.
c.client.log("Creation action wasn't supplied before Get... | go | {
"resource": ""
} |
q6351 | GetAncestorCards | train | func (c *Card) GetAncestorCards(args Arguments) (ancestors []*Card, err error) {
// Get the first parent
parent, err := c.GetParentCard(args)
if IsNotFound(err) || IsPermissionDenied(err) {
c.client.log("[trello] Can't get details about the parent of card '%s' due to lack of permissions or card deleted.", c.ID)
... | go | {
"resource": ""
} |
q6352 | GetOriginatingCard | train | func (c *Card) GetOriginatingCard(args Arguments) (*Card, error) {
ancestors, err := c.GetAncestorCards(args)
if err != nil {
return c, err
}
if len(ancestors) > 0 {
return ancestors[len(ancestors)-1], nil
}
return c, nil
} | go | {
"resource": ""
} |
q6353 | CreatorMember | train | func (c *Card) CreatorMember() (*Member, error) {
var actions ActionCollection
var err error
if len(c.Actions) == 0 {
c.Actions, err = c.GetActions(Arguments{"filter": "all", "limit": "1000", "memberCreator_fields": "all"})
if err != nil {
err = errors.Wrapf(err, "GetActions() call failed.")
return nil, e... | go | {
"resource": ""
} |
q6354 | CreatorMemberID | train | func (c *Card) CreatorMemberID() (string, error) {
var actions ActionCollection
var err error
if len(c.Actions) == 0 {
c.client.log("[trello] CreatorMemberID() called on card '%s' without any Card.Actions. Fetching fresh.", c.ID)
c.Actions, err = c.GetActions(Defaults())
if err != nil {
err = errors.Wrapf... | go | {
"resource": ""
} |
q6355 | ContainsCopyOfCard | train | func (b *Board) ContainsCopyOfCard(cardID string, args Arguments) (bool, error) {
args["filter"] = "copyCard"
actions, err := b.GetActions(args)
if err != nil {
err := errors.Wrapf(err, "GetCards() failed inside ContainsCopyOf() for board '%s' and card '%s'.", b.ID, cardID)
return false, err
}
for _, action :=... | go | {
"resource": ""
} |
q6356 | GetCard | train | func (c *Client) GetCard(cardID string, args Arguments) (card *Card, err error) {
path := fmt.Sprintf("cards/%s", cardID)
err = c.Get(path, args, &card)
if card != nil {
card.client = c
}
return card, err
} | go | {
"resource": ""
} |
q6357 | GetCards | train | func (b *Board) GetCards(args Arguments) (cards []*Card, err error) {
path := fmt.Sprintf("boards/%s/cards", b.ID)
err = b.client.Get(path, args, &cards)
// Naive implementation would return here. To make sure we get all
// cards, we begin
if len(cards) > 0 {
moreCards := true
for moreCards == true {
next... | go | {
"resource": ""
} |
q6358 | GetCards | train | func (l *List) GetCards(args Arguments) (cards []*Card, err error) {
path := fmt.Sprintf("lists/%s/cards", l.ID)
err = l.client.Get(path, args, &cards)
for i := range cards {
cards[i].client = l.client
}
return
} | go | {
"resource": ""
} |
q6359 | GetLabels | train | func (b *Board) GetLabels(args Arguments) (labels []*Label, err error) {
path := fmt.Sprintf("boards/%s/labels", b.ID)
err = b.client.Get(path, args, &labels)
return
} | go | {
"resource": ""
} |
q6360 | ToURLValues | train | func (args Arguments) ToURLValues() url.Values {
v := url.Values{}
for key, value := range args {
v.Set(key, value)
}
return v
} | go | {
"resource": ""
} |
q6361 | GetActions | train | func (b *Board) GetActions(args Arguments) (actions ActionCollection, err error) {
path := fmt.Sprintf("boards/%s/actions", b.ID)
err = b.client.Get(path, args, &actions)
return
} | go | {
"resource": ""
} |
q6362 | GetActions | train | func (l *List) GetActions(args Arguments) (actions ActionCollection, err error) {
path := fmt.Sprintf("lists/%s/actions", l.ID)
err = l.client.Get(path, args, &actions)
return
} | go | {
"resource": ""
} |
q6363 | GetActions | train | func (c *Card) GetActions(args Arguments) (actions ActionCollection, err error) {
path := fmt.Sprintf("cards/%s/actions", c.ID)
err = c.client.Get(path, args, &actions)
return
} | go | {
"resource": ""
} |
q6364 | GetMembershipChangeActions | train | func (c *Card) GetMembershipChangeActions() (actions ActionCollection, err error) {
// We include updateCard:closed as if the member is implicitly removed from the card when it's closed.
// This allows us to "close out" the duration length.
return c.GetActions(Arguments{"filter": "addMemberToCard,removeMemberFromCar... | go | {
"resource": ""
} |
q6365 | DidArchiveCard | train | func (a *Action) DidArchiveCard() bool {
return (a.Type == "updateCard") && a.Data != nil && a.Data.Card != nil && a.Data.Card.Closed
} | go | {
"resource": ""
} |
q6366 | DidUnarchiveCard | train | func (a *Action) DidUnarchiveCard() bool {
return (a.Type == "updateCard") && a.Data != nil && a.Data.Old != nil && a.Data.Old.Closed
} | go | {
"resource": ""
} |
q6367 | SearchCards | train | func (c *Client) SearchCards(query string, args Arguments) (cards []*Card, err error) {
args["query"] = query
args["modelTypes"] = "cards"
res := SearchResult{}
err = c.Get("search", args, &res)
cards = res.Cards
return
} | go | {
"resource": ""
} |
q6368 | SearchBoards | train | func (c *Client) SearchBoards(query string, args Arguments) (boards []*Board, err error) {
args["query"] = query
args["modelTypes"] = "boards"
res := SearchResult{}
err = c.Get("search", args, &res)
boards = res.Boards
for _, board := range boards {
board.client = c
}
return
} | go | {
"resource": ""
} |
q6369 | SearchMembers | train | func (c *Client) SearchMembers(query string, args Arguments) (members []*Member, err error) {
args["query"] = query
err = c.Get("search/members", args, &members)
return
} | go | {
"resource": ""
} |
q6370 | IsRateLimit | train | func IsRateLimit(err error) bool {
re, ok := err.(rateLimitError)
return ok && re.IsRateLimit()
} | go | {
"resource": ""
} |
q6371 | IsNotFound | train | func IsNotFound(err error) bool {
nf, ok := err.(notFoundError)
return ok && nf.IsNotFound()
} | go | {
"resource": ""
} |
q6372 | IsPermissionDenied | train | func IsPermissionDenied(err error) bool {
pd, ok := err.(permissionDeniedError)
return ok && pd.IsPermissionDenied()
} | go | {
"resource": ""
} |
q6373 | CreatedAt | train | func (l *List) CreatedAt() time.Time {
t, _ := IDToTime(l.ID)
return t
} | go | {
"resource": ""
} |
q6374 | GetList | train | func (c *Client) GetList(listID string, args Arguments) (list *List, err error) {
path := fmt.Sprintf("lists/%s", listID)
err = c.Get(path, args, &list)
if list != nil {
list.client = c
for i := range list.Cards {
list.Cards[i].client = c
}
}
return
} | go | {
"resource": ""
} |
q6375 | GetLists | train | func (b *Board) GetLists(args Arguments) (lists []*List, err error) {
path := fmt.Sprintf("boards/%s/lists", b.ID)
err = b.client.Get(path, args, &lists)
for i := range lists {
lists[i].client = b.client
for j := range lists[i].Cards {
lists[i].Cards[j].client = b.client
}
}
return
} | go | {
"resource": ""
} |
q6376 | IDToTime | train | func IDToTime(id string) (t time.Time, err error) {
if id == "" {
return time.Time{}, nil
}
// The first 8 characters in the object ID are a Unix timestamp
ts, err := strconv.ParseUint(id[:8], 16, 64)
if err != nil {
err = errors.Wrapf(err, "ID '%s' failed to convert to timestamp.", id)
} else {
t = time.Un... | go | {
"resource": ""
} |
q6377 | AddDuration | train | func (l *ListDuration) AddDuration(d time.Duration) {
l.Duration = l.Duration + d
l.TimesInList++
} | go | {
"resource": ""
} |
q6378 | GetListDurations | train | func (c *Card) GetListDurations() (durations []*ListDuration, err error) {
var actions ActionCollection
if len(c.Actions) == 0 {
// Get all actions which affected the Card's List
c.client.log("[trello] GetListDurations() called on card '%s' without any Card.Actions. Fetching fresh.", c.ID)
actions, err = c.Get... | go | {
"resource": ""
} |
q6379 | GetListDurations | train | func (actions ActionCollection) GetListDurations() (durations []*ListDuration, err error) {
sort.Sort(actions)
var prevTime time.Time
var prevList *List
durs := make(map[string]*ListDuration)
for _, action := range actions {
if action.DidChangeListForCard() {
if prevList != nil {
duration := action.Date... | go | {
"resource": ""
} |
q6380 | DefaultAlertConfig | train | func DefaultAlertConfig() *ConsulAlertConfig {
checks := &ChecksConfig{
Enabled: true,
ChangeThreshold: 60,
}
events := &EventsConfig{
Enabled: true,
Handlers: []string{},
}
email := ¬ifier.EmailNotifier{
ClusterName: "Consul-Alerts",
Enabled: false,
SenderAlias: "Consul Alerts",
... | go | {
"resource": ""
} |
q6381 | sendEvent | train | func (il *ILertNotifier) sendEvent(event iLertEvent) error {
body, err := json.Marshal(event)
if err != nil {
return err
}
res, err := http.Post(apiEndpoint, "application/json", bytes.NewBuffer(body))
if err != nil {
return err
}
defer res.Body.Close()
if res.StatusCode != 200 {
body, _ := ioutil.ReadA... | go | {
"resource": ""
} |
q6382 | GetReminders | train | func (c *ConsulAlertClient) GetReminders() []notifier.Message {
remindersList, _, _ := c.api.KV().List("consul-alerts/reminders", nil)
var messages []notifier.Message
for _, kvpair := range remindersList {
var message notifier.Message
json.Unmarshal(kvpair.Value, &message)
messages = append(messages, message)
... | go | {
"resource": ""
} |
q6383 | SetReminder | train | func (c *ConsulAlertClient) SetReminder(m notifier.Message) {
data, _ := json.Marshal(m)
key := fmt.Sprintf("consul-alerts/reminders/%s/%s", m.Node, m.CheckId)
c.api.KV().Put(&consulapi.KVPair{Key: key, Value: data}, nil)
log.Println("Setting reminder for node: ", m.Node)
} | go | {
"resource": ""
} |
q6384 | DeleteReminder | train | func (c *ConsulAlertClient) DeleteReminder(node string, checkid string) {
key := fmt.Sprintf("consul-alerts/reminders/%s/%s", node, checkid)
c.api.KV().Delete(key, nil)
log.Println("Deleting reminder for node: ", node)
} | go | {
"resource": ""
} |
q6385 | NewAlerts | train | func (c *ConsulAlertClient) NewAlerts() []Check {
allChecks, _, _ := c.api.KV().List("consul-alerts/checks", nil)
var alerts []Check
for _, kvpair := range allChecks {
key := kvpair.Key
if strings.HasSuffix(key, "/") {
continue
}
var status Status
json.Unmarshal(kvpair.Value, &status)
if status.ForNot... | go | {
"resource": ""
} |
q6386 | CustomNotifiers | train | func (c *ConsulAlertClient) CustomNotifiers() (customNotifs map[string]string) {
if kvPairs, _, err := c.api.KV().List("consul-alerts/config/notifiers/custom", nil); err == nil {
customNotifs = make(map[string]string)
for _, kvPair := range kvPairs {
rp := regexp.MustCompile("/([^/]*)$")
match := rp.FindStri... | go | {
"resource": ""
} |
q6387 | getProfileForEntity | train | func (c *ConsulAlertClient) getProfileForEntity(entity string, id string) string {
kvPair, _, _ := c.api.KV().Get(
fmt.Sprintf("consul-alerts/config/notif-selection/%ss/%s",
entity, id), nil)
if kvPair != nil {
log.Printf("%s selection key found.\n", entity)
return string(kvPair.Value)
} else if kvPair, _, ... | go | {
"resource": ""
} |
q6388 | GetProfileInfo | train | func (c *ConsulAlertClient) GetProfileInfo(node, serviceID, checkID, status string) ProfileInfo {
log.Println("Getting profile for node: ", node, " service: ", serviceID, " check: ", checkID)
var profile string
profile = c.getProfileForService(serviceID)
if profile == "" {
profile = c.getProfileForCheck(checkID... | go | {
"resource": ""
} |
q6389 | IsBlacklisted | train | func (c *ConsulAlertClient) IsBlacklisted(check *Check) bool {
blacklistExist := func() bool {
kvPairs, _, err := c.api.KV().List("consul-alerts/config/checks/blacklist/", nil)
return len(kvPairs) != 0 && err == nil
}
node := check.Node
nodeCheckKey := fmt.Sprintf("consul-alerts/config/checks/blacklist/nodes/%... | go | {
"resource": ""
} |
q6390 | New | train | func New(possible []string, subsetSize []int) *ClosestMatch {
cm := new(ClosestMatch)
cm.SubstringSizes = subsetSize
cm.SubstringToID = make(map[string]map[uint32]struct{})
cm.ID = make(map[uint32]IDInfo)
for i, s := range possible {
substrings := cm.splitWord(strings.ToLower(s))
cm.ID[uint32(i)] = IDInfo{Key:... | go | {
"resource": ""
} |
q6391 | Load | train | func Load(filename string) (*ClosestMatch, error) {
cm := new(ClosestMatch)
f, err := os.Open(filename)
defer f.Close()
if err != nil {
return cm, err
}
w, err := gzip.NewReader(f)
if err != nil {
return cm, err
}
err = json.NewDecoder(w).Decode(&cm)
return cm, err
} | go | {
"resource": ""
} |
q6392 | Add | train | func (cm *ClosestMatch) Add(possible []string) {
cm.mux.Lock()
for i, s := range possible {
substrings := cm.splitWord(strings.ToLower(s))
cm.ID[uint32(i)] = IDInfo{Key: s, NumSubstrings: len(substrings)}
for substring := range substrings {
if _, ok := cm.SubstringToID[substring]; !ok {
cm.SubstringToID[... | go | {
"resource": ""
} |
q6393 | Save | train | func (cm *ClosestMatch) Save(filename string) error {
f, err := os.Create(filename)
if err != nil {
return err
}
defer f.Close()
w := gzip.NewWriter(f)
defer w.Close()
enc := json.NewEncoder(w)
// enc.SetIndent("", " ")
return enc.Encode(cm)
} | go | {
"resource": ""
} |
q6394 | Closest | train | func (cm *ClosestMatch) Closest(searchWord string) string {
for _, pair := range rankByWordCount(cm.match(searchWord)) {
return pair.Key
}
return ""
} | go | {
"resource": ""
} |
q6395 | ClosestN | train | func (cm *ClosestMatch) ClosestN(searchWord string, max int) []string {
matches := make([]string, 0, max)
for i, pair := range rankByWordCount(cm.match(searchWord)) {
if i >= max {
break
}
matches = append(matches, pair.Key)
}
return matches
} | go | {
"resource": ""
} |
q6396 | Open | train | func Open(address string) (*Connection, error) {
c := new(Connection)
c.Address = address
resp, err := http.Get(c.Address + "/uptime")
if err != nil {
return c, err
}
defer resp.Body.Close()
return c, nil
} | go | {
"resource": ""
} |
q6397 | UnmarshalYAML | train | func (u *URL) UnmarshalYAML(unmarshal func(interface{}) error) error {
var s string
if err := unmarshal(&s); err != nil {
return err
}
urlp, err := url.Parse(s)
if err != nil {
return err
}
u.URL = urlp
return nil
} | go | {
"resource": ""
} |
q6398 | MarshalYAML | train | func (u URL) MarshalYAML() (interface{}, error) {
if u.URL != nil {
return u.String(), nil
}
return nil, nil
} | go | {
"resource": ""
} |
q6399 | Validate | train | func (c *HTTPClientConfig) Validate() error {
if len(c.BearerToken) > 0 && len(c.BearerTokenFile) > 0 {
return fmt.Errorf("at most one of bearer_token & bearer_token_file must be configured")
}
if c.BasicAuth != nil && (len(c.BearerToken) > 0 || len(c.BearerTokenFile) > 0) {
return fmt.Errorf("at most one of bas... | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.