id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1
value |
|---|---|---|
c17800 |
servers[k] = strings.Trim(names[0], ".")
}
return strings.Join(servers, ",")
} | |
c17801 | json.Unmarshall using a type != Unmarshaller
// This avoid enter in a infinite loop
type t CheckResponseType
var rawCheckDetails t
err := json.Unmarshal(b, &rawCheckDetails)
if err != nil {
return err
}
c.HTTP = rawCheckDetails.HTTP
c.TCP = rawCheckDetails.TCP
}
return nil
} | |
c17802 | fmt.Sprintf("%d %v: %v", r.StatusCode, r.StatusDesc, r.Message)
} | |
c17803 | _ := ioutil.ReadAll(resp.Body)
bodyString := string(bodyBytes)
t := &listPublicReportsJSONResponse{}
err = json.Unmarshal([]byte(bodyString), &t)
return t.Checks, err
} | |
c17804 | &PingdomResponse{}
_, err = cs.client.Do(req, t)
if err != nil {
return nil, err
}
return t, err
} | |
c17805 | "name": ck.Name,
}
// Ignore if not defined
if ck.UserIds != "" {
t["userids"] = ck.UserIds
}
return t
} | |
c17806 |
return nil, err
}
bodyBytes, _ := ioutil.ReadAll(resp.Body)
bodyString := string(bodyBytes)
p := &listProbesJSONResponse{}
err = json.Unmarshal([]byte(bodyString), &p)
return p.Probes, err
} | |
c17807 | a phone number")
}
if c.Provider != "" && (c.Number == "" || c.CountryCode == "") {
return fmt.Errorf("you must provide CountryCode and Number if Provider is provided")
}
return nil
} | |
c17808 | {
m := map[string]string{
"name": u.Username,
}
return m
} | |
c17809 |
m["countrycode"] = c.CountryCode
}
if c.Severity != "" {
m["severitylevel"] = c.Severity
}
if c.Provider != "" {
m["provider"] = c.Provider
}
return m
} | |
c17810 | }
if u.Primary != "" {
m["primary"] = u.Primary
}
if u.Paused != "" {
m["paused"] = u.Paused
}
return m
} | |
c17811 |
if err := validateResponse(resp); err != nil {
return nil, err
}
bodyBytes, _ := ioutil.ReadAll(resp.Body)
bodyString := string(bodyBytes)
m := &listMaintenanceJSONResponse{}
err = json.Unmarshal([]byte(bodyString), &m)
return m.Maintenances, err
} | |
c17812 | &maintenanceDetailsJSONResponse{}
_, err = cs.client.Do(req, m)
if err != nil {
return nil, err
}
return m.Maintenance, err
} | |
c17813 |
m := &maintenanceDetailsJSONResponse{}
_, err = cs.client.Do(req, m)
if err != nil {
return nil, err
}
return m.Maintenance, err
} | |
c17814 | != nil {
return nil, err
}
m := &PingdomResponse{}
_, err = cs.client.Do(req, m)
if err != nil {
return nil, err
}
return m, err
} | |
c17815 | return nil, err
}
m := &PingdomResponse{}
_, err = cs.client.Do(req, m)
if err != nil {
return nil, err
}
return m, err
} | |
c17816 |
return nil, err
}
defer resp.Body.Close()
if err := validateResponse(resp); err != nil {
return nil, err
}
bodyBytes, _ := ioutil.ReadAll(resp.Body)
bodyString := string(bodyBytes)
u := &listUsersJSONResponse{}
err = json.Unmarshal([]byte(bodyString), &u)
return u.Users, err
} | |
c17817 | {
return &users[i], nil
}
}
return nil, fmt.Errorf("UserId: " + strconv.Itoa(userID) + " not found")
} | |
c17818 | m := &createUserJSONResponse{}
_, err = cs.client.Do(req, m)
if err != nil {
return nil, err
}
return m.User, err
} | |
c17819 | := cs.client.NewRequest("POST", "/users/"+strconv.Itoa(userID), contact.PostContactParams())
if err != nil {
return nil, err
}
m := &createUserContactJSONResponse{}
_, err = cs.client.Do(req, m)
if err != nil {
return nil, err
}
return m.Contact, err
} | |
c17820 | cs.client.NewRequest("PUT", "/users/"+strconv.Itoa(id), user.PutParams())
if err != nil {
return nil, err
}
m := &PingdomResponse{}
_, err = cs.client.Do(req, m)
if err != nil {
return nil, err
}
return m, err
} | |
c17821 | nil {
return nil, err
}
m := &PingdomResponse{}
_, err = cs.client.Do(req, m)
if err != nil {
return nil, err
}
return m, err
} | |
c17822 |
if err != nil {
return nil, err
}
m := &PingdomResponse{}
_, err = cs.client.Do(req, m)
if err != nil {
return nil, err
}
return m, err
} | |
c17823 |
return nil, err
}
defer resp.Body.Close()
if err := validateResponse(resp); err != nil {
return nil, err
}
bodyBytes, _ := ioutil.ReadAll(resp.Body)
bodyString := string(bodyBytes)
t := &listTeamsJSONResponse{}
err = json.Unmarshal([]byte(bodyString), &t)
return t.Teams, err
} | |
c17824 | &teamDetailsJSONResponse{}
_, err = cs.client.Do(req, t)
if err != nil {
return nil, err
}
return t.Team, err
} | |
c17825 | t := &TeamResponse{}
_, err = cs.client.Do(req, t)
if err != nil {
return nil, err
}
return t, err
} | |
c17826 | &TeamResponse{}
_, err = cs.client.Do(req, t)
if err != nil {
return nil, err
}
return t, err
} | |
c17827 | &TeamDeleteResponse{}
_, err = cs.client.Do(req, t)
if err != nil {
return nil, err
}
return t, err
} | |
c17828 | m["tmsids"] = ck.TmsIDs
}
if ck.RepeatEvery != 0 {
m["repeatevery"] = strconv.Itoa(ck.RepeatEvery)
}
if ck.EffectiveTo != 0 {
m["effectiveto"] = strconv.Itoa(ck.EffectiveTo)
}
return m
} | |
c17829 | Must contain time")
}
if ck.To == 0 {
return fmt.Errorf("Invalid value for `To`. Must contain time")
}
return nil
} | |
c17830 | {
m := map[string]string{
"maintenanceids": ck.MaintenanceIDs,
}
return m
} | |
c17831 |
return nil, err
}
bodyBytes, _ := ioutil.ReadAll(resp.Body)
bodyString := string(bodyBytes)
m := &listChecksJSONResponse{}
err = json.Unmarshal([]byte(bodyString), &m)
return m.Checks, err
} | |
c17832 | := &checkDetailsJSONResponse{}
_, err = cs.client.Do(req, m)
if err != nil {
return nil, err
}
return m.Check, err
} | |
c17833 | != nil {
return nil, err
}
m.Check.TeamIds = make([]int, len(m.Check.Teams))
for i := range m.Check.Teams {
m.Check.TeamIds[i] = m.Check.Teams[i].ID
}
return m.Check, err
} | |
c17834 | "/checks/"+strconv.Itoa(id), check.PutParams())
if err != nil {
return nil, err
}
m := &PingdomResponse{}
_, err = cs.client.Do(req, m)
if err != nil {
return nil, err
}
return m, err
} | |
c17835 | &PingdomResponse{}
_, err = cs.client.Do(req, m)
if err != nil {
return nil, err
}
return m, err
} | |
c17836 | != nil {
return nil, err
}
m := &SummaryPerformanceResponse{}
_, err = cs.client.Do(req, m)
if err != nil {
return nil, err
}
return m, nil
} | |
c17837 |
c.client = config.HTTPClient
} else {
c.client = http.DefaultClient
}
c.Checks = &CheckService{client: c}
c.Maintenances = &MaintenanceService{client: c}
c.Probes = &ProbeService{client: c}
c.Teams = &TeamService{client: c}
c.PublicReport = &PublicReportService{client: c}
c.Users = &UserService{client: c}... | |
c17838 | for k, v := range params {
ps.Set(k, v)
}
baseURL.RawQuery = ps.Encode()
}
req, err := http.NewRequest(method, baseURL.String(), nil)
req.SetBasicAuth(pc.User, pc.Password)
req.Header.Add("App-Key", pc.APIKey)
if pc.AccountEmail != "" {
req.Header.Add("Account-Email", pc.AccountEmail)
}
return req, e... | |
c17839 | validateResponse(resp); err != nil {
return resp, err
}
err = decodeResponse(resp, v)
return resp, err
} | |
c17840 | &errorJSONResponse{}
err := json.Unmarshal([]byte(bodyString), &m)
if err != nil {
return err
}
return m.Error
} | |
c17841 | But we must define one so they can be emptied if required.
if ck.ShouldContain != "" {
m["shouldcontain"] = ck.ShouldContain
} else {
m["shouldnotcontain"] = ck.ShouldNotContain
}
// Convert auth
if ck.Username != "" {
m["auth"] = fmt.Sprintf("%s:%s", ck.Username, ck.Password)
}
// Convert headers
var ... | |
c17842 | delete(params, k)
}
}
params["type"] = "http"
return params
} | |
c17843 | && ck.Resolution != 5 && ck.Resolution != 15 &&
ck.Resolution != 30 && ck.Resolution != 60 {
return fmt.Errorf("invalid value %v for `Resolution`, allowed values are [1,5,15,30,60]", ck.Resolution)
}
if ck.ShouldContain != "" && ck.ShouldNotContain != "" {
return fmt.Errorf("`ShouldContain` and `ShouldNotCont... | |
c17844 | intListToCDString(ck.TeamIds),
}
if ck.SendNotificationWhenDown != 0 {
m["sendnotificationwhendown"] = strconv.Itoa(ck.SendNotificationWhenDown)
}
if ck.ResponseTimeThreshold != 0 {
m["responsetime_threshold"] = strconv.Itoa(ck.ResponseTimeThreshold)
}
return m
} | |
c17845 | 5 && ck.Resolution != 15 &&
ck.Resolution != 30 && ck.Resolution != 60 {
return fmt.Errorf("invalid value %v for `Resolution`, allowed values are [1,5,15,30,60]", ck.Resolution)
}
return nil
} | |
c17846 | "probe_filters": ck.ProbeFilters,
"tags": ck.Tags,
"userids": intListToCDString(ck.UserIds),
"teamids": intListToCDString(ck.TeamIds),
"port": strconv.Itoa(ck.Port),
}
if ck.SendNotificationWhenDown != 0 {
m["sendnotificationwhendown"] = strconv.Itoa(ck.SendNo... | |
c17847 |
if ck.Resolution != 1 && ck.Resolution != 5 && ck.Resolution != 15 &&
ck.Resolution != 30 && ck.Resolution != 60 {
return fmt.Errorf("invalid value %v for `Resolution`, allowed values are [1,5,15,30,60]", ck.Resolution)
}
if ck.Port < 1 {
return fmt.Errorf("Invalid value for `Port`. Must contain an integer... | |
c17848 | != "day" && csr.Resolution != "week" {
return ErrBadResolution
}
return nil
} | |
c17849 | params["resolution"] = csr.Resolution
}
if csr.IncludeUptime {
params["includeuptime"] = "true"
}
return
} | |
c17850 | ma.Join(parts[len(parts)-len(trailer):]...).Equal(ma.Join(trailer...)) {
return true
}
return false
} | |
c17851 | := <-discoverNATPMP():
return nat, nil
case <-time.After(10 * time.Second):
return nil, ErrNoNATFound
}
} | |
c17852 | = append(IS.WordIndex, 0)
copy(IS.WordIndex[k+1:], IS.WordIndex[k:])
IS.WordIndex[k] = i
IS.SuffixIndex = append(IS.SuffixIndex, 0)
copy(IS.SuffixIndex[k+1:], IS.SuffixIndex[k:])
IS.SuffixIndex[k] = j
}
} | |
c17853 |
// Transpose Character
temp := make([]byte, N)
copy(temp, Word)
temp[i], temp[i-1] = temp[i-1], temp[i]
results = append(results, temp)
}
// Insert Character
for _, c := range AllowedBytes {
if c == t {
continue
}
temp := make([]byte, N)
copy(temp, Word)
temp[i] = c
results =... | |
c17854 | {
return a
}
return r
} | |
c17855 | rune) rune { return unicode.ToLower(ToASCII(r)) }, s))
} | |
c17856 | g := new(proto.GossiperImpl)
g.Init(ip, selfNodeId, genNumber, gossipIntervals, gossipVersion, clusterId, selfFailureDomain)
return g
} | |
c17857 |
msg := gd.MetaInfo()
msgBytes, _ := gd.convertToBytes(msg)
return msgBytes
} | |
c17858 | // gossip version mismatches.
// Nevertheless we are doing an extra check here.
if err := gd.gossipChecks(node); err != nil {
gd.RemoveNode(types.NodeId(nodeName))
}
} | |
c17859 | if isSuspect {
gd.setNodeAsSuspectOffline(nodeName)
} else {
gd.setNodeOffline(nodeName)
}
}()
} else {
gd.setNodeOffline(nodeName)
}
}
gd.updateGossipTs()
return
} | |
c17860 | continue
}
logrus.Infof("gossip: pinging peer node (%v: %v) for suspect %v", fdNodeId, nodeInfo.Addr, nodeId)
_, pingErr := gd.ping(fdNodeId, nodeInfo.Addr)
if pingErr != nil {
// Ping to a node in the same cluster domain as the suspected node
// failed. Try another node
logrus.Infof("gossip: ping to... | |
c17861 | pcf,
probationTasks: make(map[string]sched.TaskID),
schedInst: sched.Instance(),
}
return p
} | |
c17862 | _ := f.activeMap[ipDomain]
if isActive == types.CLUSTER_DOMAIN_STATE_ACTIVE {
return true
}
return false
} | |
c17863 | selfId: selfId,
}
}
return &failureDomainsQuorum{
selfId: selfId,
}
} | |
c17864 | day 5 (Friday) and rollover is on day 4 (Thursday).
// Days to rollover is 6 - 5 + 4 + 1, or 6.) In this case,
// it's the number of days left in the current week (1) plus
// the number of days in the next week until the
// rollover day (5).
// THe calculations described in 2... | |
c17865 | (bool, string) {
overTime := time.Now().After(self.rolloverTime)
return overTime, self.Format(record)
} | |
c17866 | }
}
}
// no need to sort fileNames since ioutil.ReadDir() returns sorted list.
var result []string
if uint32(len(fileNames)) < self.backupCount {
return result, nil
}
result = fileNames[:uint32(len(fileNames))-self.backupCount]
for i := 0; i < len(result); i++ {
result[i] = filepath.Join(dirName, result[i... | |
c17867 | LevelInfo:
err = self.writer.Info(message)
case LevelDebug:
err = self.writer.Debug(message)
default:
_, err = self.writer.Write([]byte(message))
}
return err
} | |
c17868 | &BaseRotatingHandler{
FileHandler: fileHandler,
}
Closer.RemoveHandler(object.FileHandler)
Closer.AddHandler(object)
return object, nil
} | |
c17869 | := handler.DoRollover(); err != nil {
return err
}
}
// Message already has a trailing '\n'.
err := self.GetStream().Write(message)
if err != nil {
return err
}
return nil
} | |
c17870 | offset info
return false, message
}
if (uint64(offset) + uint64(len(message))) > self.maxBytes {
return true, message
}
}
return false, message
} | |
c17871 |
}
}
if err := os.Rename(sourceFile, destFile); err != nil {
return err
}
}
return nil
} | |
c17872 | := self.backupCount - 1; i > 0; i-- {
sourceFile := fmt.Sprintf("%s.%d", filepath, i)
destFile := fmt.Sprintf("%s.%d", filepath, i+1)
if err := self.RotateFile(sourceFile, destFile); err != nil {
return err
}
}
destFile := fmt.Sprintf("%s.%d", filepath, 1)
if err := self.RotateFile(filepath, dest... | |
c17873 | retry: retry,
}
object.makeConnFunc = object.makeTCPSocket
object.sendFunc = object.sendTCP
Closer.AddHandler(object)
return object
} | |
c17874 | record.UseFormat,
Message: record.Message,
}
var buf bytes.Buffer
encoder := gob.NewEncoder(&buf)
err := encoder.Encode(r)
if err != nil {
return nil, err
}
return buf.Bytes(), nil
} | |
c17875 | self.port)
conn, err := net.DialTimeout(network, address, SocketDefaultTimeout)
if err != nil {
return err
}
self.conn = conn
return nil
} | |
c17876 |
sent, err := self.conn.Write(bin[sentSoFar:])
if err != nil {
return err
}
sentSoFar += sent
left -= sent
}
return nil
} | |
c17877 | err := self.createSocket()
if err != nil {
return err
}
}
_, err := self.conn.Write(bin)
return err
} | |
c17878 |
bin, err := self.Marshal(record)
if err != nil {
return err
}
return self.sendFunc(bin)
} | |
c17879 | self.conn = nil
} else {
self.BaseHandler.HandleError(record, err)
}
} | |
c17880 |
self.conn = nil
}
self.BaseHandler.Close()
} | |
c17881 | } else if self.name == record.Name {
return true
} else if !strings.HasPrefix(record.Name, self.name) {
return false
}
return (record.Name[length] == '.')
} | |
c17882 | {
if !self.filters.SetContains(filter) {
self.filters.SetAdd(filter)
}
} | |
c17883 | {
if self.filters.SetContains(filter) {
self.filters.SetRemove(filter)
}
} | |
c17884 | return manager.GetLogger(name)
} else {
return root
}
} | |
c17885 | root.Logf(level, format, args...)
} | |
c17886 |
mode: mode,
bufferSize: bufferSize,
}
if err = object.Open(); err != nil {
return nil, err
}
Closer.RemoveHandler(object.StreamHandler)
Closer.AddHandler(object)
return object, nil
} | |
c17887 |
return ApplyYAMLConfigFile(file)
default:
return errors.New(fmt.Sprintf(
"unknown format of the specified file: %s", file))
}
} | |
c17888 | if err = decoder.Decode(&conf); err != nil {
return err
}
return DictConfig(&conf)
} | |
c17889 | {
return err
}
var conf Conf
if err = yaml.Unmarshal(bin, &conf); err != nil {
return err
}
return DictConfig(&conf)
} | |
c17890 | StandardFilterer: NewStandardFilterer(),
name: name,
level: level,
formatter: nil,
}
} | |
c17891 | {
formatter = self.formatter
} else {
formatter = defaultFormatter
}
return formatter.Format(record)
} | |
c17892 | levelToNames[level] = levelName
nameToLevels[levelName] = level
} | |
c17893 | Loggers: NewListSet(),
}
object.Append(logger)
return object
} | |
c17894 | {
self.Loggers.SetAdd(logger)
}
} | |
c17895 | funcName := runtime.FuncForPC(pc).Name()
return &CallerInfo{
PathName: filepath,
FileName: file,
LineNo: uint32(line),
FuncName: funcName,
}
}
}
} | |
c17896 |
level: level,
propagate: true,
handlers: NewListSet(),
manager: nil,
}
return object
} | |
c17897 | != LevelNotset {
return level
}
logger = logger.GetParent()
}
return LevelNotset
} | |
c17898 | if !call.GetPropagate() {
call = nil
} else {
call = call.GetParent()
}
}
} | |
c17899 | logger.SetPropagate(false)
return &RootLogger{
StandardLogger: logger,
}
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.