_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3 values | text stringlengths 52 85.5k | language stringclasses 1 value | meta_information dict |
|---|---|---|---|---|---|
q17800 | FixNameServers | train | func FixNameServers(nservers string) string {
servers := strings.Split(nservers, ",")
for k, v := range servers {
names := strings.Split(strings.TrimSpace(v), " ")
servers[k] = strings.Trim(names[0], ".")
}
return strings.Join(servers, ",")
} | go | {
"resource": ""
} |
q17801 | UnmarshalJSON | train | func (c *CheckResponseType) UnmarshalJSON(b []byte) error {
var raw interface{}
err := json.Unmarshal(b, &raw)
if err != nil {
return err
}
switch v := raw.(type) {
case string:
c.Name = v
case map[string]interface{}:
if len(v) != 1 {
return fmt.Errorf("Check detailed response `check.type` contains more than one object: %+v", v)
}
for k := range v {
c.Name = k
}
// Allow continue use 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
} | go | {
"resource": ""
} |
q17802 | Error | train | func (r *PingdomError) Error() string {
return fmt.Sprintf("%d %v: %v", r.StatusCode, r.StatusDesc, r.Message)
} | go | {
"resource": ""
} |
q17803 | List | train | func (cs *PublicReportService) List() ([]PublicReportResponse, error) {
req, err := cs.client.NewRequest("GET", "/reports.public", nil)
if err != nil {
return nil, err
}
resp, err := cs.client.client.Do(req)
if err != nil {
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 := &listPublicReportsJSONResponse{}
err = json.Unmarshal([]byte(bodyString), &t)
return t.Checks, err
} | go | {
"resource": ""
} |
q17804 | PublishCheck | train | func (cs *PublicReportService) PublishCheck(id int) (*PingdomResponse, error) {
req, err := cs.client.NewRequest("PUT", "/reports.public/"+strconv.Itoa(id), nil)
if err != nil {
return nil, err
}
t := &PingdomResponse{}
_, err = cs.client.Do(req, t)
if err != nil {
return nil, err
}
return t, err
} | go | {
"resource": ""
} |
q17805 | PutParams | train | func (ck *TeamData) PutParams() map[string]string {
t := map[string]string{
"name": ck.Name,
}
// Ignore if not defined
if ck.UserIds != "" {
t["userids"] = ck.UserIds
}
return t
} | go | {
"resource": ""
} |
q17806 | List | train | func (cs *ProbeService) List(params ...map[string]string) ([]ProbeResponse, error) {
param := map[string]string{}
if len(params) == 1 {
param = params[0]
}
req, err := cs.client.NewRequest("GET", "/probes", param)
if err != nil {
return nil, err
}
resp, err := cs.client.client.Do(req)
if err != nil {
return nil, err
}
defer resp.Body.Close()
if err := validateResponse(resp); err != nil {
return nil, err
}
bodyBytes, _ := ioutil.ReadAll(resp.Body)
bodyString := string(bodyBytes)
p := &listProbesJSONResponse{}
err = json.Unmarshal([]byte(bodyString), &p)
return p.Probes, err
} | go | {
"resource": ""
} |
q17807 | ValidContact | train | func (c *Contact) ValidContact() error {
if c.Email == "" && c.Number == "" {
return fmt.Errorf("you must provide either an Email or a Phone Number to create a contact target")
}
if c.Number != "" && c.CountryCode == "" {
return fmt.Errorf("you must provide a Country Code if providing 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
} | go | {
"resource": ""
} |
q17808 | PostParams | train | func (u *User) PostParams() map[string]string {
m := map[string]string{
"name": u.Username,
}
return m
} | go | {
"resource": ""
} |
q17809 | PostContactParams | train | func (c *Contact) PostContactParams() map[string]string {
m := map[string]string{}
// Ignore if not defined
if c.Email != "" {
m["email"] = c.Email
}
if c.Number != "" {
m["number"] = c.Number
}
if c.CountryCode != "" {
m["countrycode"] = c.CountryCode
}
if c.Severity != "" {
m["severitylevel"] = c.Severity
}
if c.Provider != "" {
m["provider"] = c.Provider
}
return m
} | go | {
"resource": ""
} |
q17810 | PutParams | train | func (u *User) PutParams() map[string]string {
m := map[string]string{
"name": u.Username,
}
if u.Primary != "" {
m["primary"] = u.Primary
}
if u.Paused != "" {
m["paused"] = u.Paused
}
return m
} | go | {
"resource": ""
} |
q17811 | List | train | func (cs *MaintenanceService) List(params ...map[string]string) ([]MaintenanceResponse, error) {
param := map[string]string{}
if len(params) != 0 {
for _, m := range params {
for k, v := range m {
param[k] = v
}
}
}
req, err := cs.client.NewRequest("GET", "/maintenance", param)
if err != nil {
return nil, err
}
resp, err := cs.client.client.Do(req)
if err != nil {
return nil, err
}
defer resp.Body.Close()
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
} | go | {
"resource": ""
} |
q17812 | Read | train | func (cs *MaintenanceService) Read(id int) (*MaintenanceResponse, error) {
req, err := cs.client.NewRequest("GET", "/maintenance/"+strconv.Itoa(id), nil)
if err != nil {
return nil, err
}
m := &maintenanceDetailsJSONResponse{}
_, err = cs.client.Do(req, m)
if err != nil {
return nil, err
}
return m.Maintenance, err
} | go | {
"resource": ""
} |
q17813 | Create | train | func (cs *MaintenanceService) Create(maintenance Maintenance) (*MaintenanceResponse, error) {
if err := maintenance.Valid(); err != nil {
return nil, err
}
req, err := cs.client.NewRequest("POST", "/maintenance", maintenance.PostParams())
if err != nil {
return nil, err
}
m := &maintenanceDetailsJSONResponse{}
_, err = cs.client.Do(req, m)
if err != nil {
return nil, err
}
return m.Maintenance, err
} | go | {
"resource": ""
} |
q17814 | Update | train | func (cs *MaintenanceService) Update(id int, maintenance Maintenance) (*PingdomResponse, error) {
if err := maintenance.Valid(); err != nil {
return nil, err
}
req, err := cs.client.NewRequest("PUT", "/maintenance/"+strconv.Itoa(id), maintenance.PutParams())
if err != nil {
return nil, err
}
m := &PingdomResponse{}
_, err = cs.client.Do(req, m)
if err != nil {
return nil, err
}
return m, err
} | go | {
"resource": ""
} |
q17815 | MultiDelete | train | func (cs *MaintenanceService) MultiDelete(maintenance MaintenanceDelete) (*PingdomResponse, error) {
if err := maintenance.ValidDelete(); err != nil {
return nil, err
}
req, err := cs.client.NewRequest("DELETE", "/maintenance/", maintenance.DeleteParams())
if err != nil {
return nil, err
}
m := &PingdomResponse{}
_, err = cs.client.Do(req, m)
if err != nil {
return nil, err
}
return m, err
} | go | {
"resource": ""
} |
q17816 | List | train | func (cs *UserService) List() ([]UsersResponse, error) {
req, err := cs.client.NewRequest("GET", "/users", nil)
if err != nil {
return nil, err
}
resp, err := cs.client.client.Do(req)
if err != nil {
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
} | go | {
"resource": ""
} |
q17817 | Read | train | func (cs *UserService) Read(userID int) (*UsersResponse, error) {
users, err := cs.List()
if err != nil {
return nil, err
}
for i := range users {
if users[i].Id == userID {
return &users[i], nil
}
}
return nil, fmt.Errorf("UserId: " + strconv.Itoa(userID) + " not found")
} | go | {
"resource": ""
} |
q17818 | Create | train | func (cs *UserService) Create(user UserApi) (*UsersResponse, error) {
if err := user.ValidUser(); err != nil {
return nil, err
}
req, err := cs.client.NewRequest("POST", "/users", user.PostParams())
if err != nil {
return nil, err
}
m := &createUserJSONResponse{}
_, err = cs.client.Do(req, m)
if err != nil {
return nil, err
}
return m.User, err
} | go | {
"resource": ""
} |
q17819 | CreateContact | train | func (cs *UserService) CreateContact(userID int, contact Contact) (*CreateUserContactResponse, error) {
if err := contact.ValidContact(); err != nil {
return nil, err
}
req, err := 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
} | go | {
"resource": ""
} |
q17820 | Update | train | func (cs *UserService) Update(id int, user UserApi) (*PingdomResponse, error) {
if err := user.ValidUser(); err != nil {
return nil, err
}
req, err := 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
} | go | {
"resource": ""
} |
q17821 | UpdateContact | train | func (cs *UserService) UpdateContact(userID int, contactID int, contact Contact) (*PingdomResponse, error) {
if err := contact.ValidContact(); err != nil {
return nil, err
}
req, err := cs.client.NewRequest("PUT", "/users/"+strconv.Itoa(userID)+"/"+strconv.Itoa(contactID), contact.PutContactParams())
if err != nil {
return nil, err
}
m := &PingdomResponse{}
_, err = cs.client.Do(req, m)
if err != nil {
return nil, err
}
return m, err
} | go | {
"resource": ""
} |
q17822 | DeleteContact | train | func (cs *UserService) DeleteContact(userID int, contactID int) (*PingdomResponse, error) {
req, err := cs.client.NewRequest("DELETE", "/users/"+strconv.Itoa(userID)+"/"+strconv.Itoa(contactID), nil)
if err != nil {
return nil, err
}
m := &PingdomResponse{}
_, err = cs.client.Do(req, m)
if err != nil {
return nil, err
}
return m, err
} | go | {
"resource": ""
} |
q17823 | List | train | func (cs *TeamService) List() ([]TeamResponse, error) {
req, err := cs.client.NewRequest("GET", "/teams", nil)
if err != nil {
return nil, err
}
resp, err := cs.client.client.Do(req)
if err != nil {
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
} | go | {
"resource": ""
} |
q17824 | Read | train | func (cs *TeamService) Read(id int) (*TeamResponse, error) {
req, err := cs.client.NewRequest("GET", "/teams/"+strconv.Itoa(id), nil)
if err != nil {
return nil, err
}
t := &teamDetailsJSONResponse{}
_, err = cs.client.Do(req, t)
if err != nil {
return nil, err
}
return t.Team, err
} | go | {
"resource": ""
} |
q17825 | Create | train | func (cs *TeamService) Create(team Team) (*TeamResponse, error) {
if err := team.Valid(); err != nil {
return nil, err
}
req, err := cs.client.NewRequest("POST", "/teams", team.PostParams())
if err != nil {
return nil, err
}
t := &TeamResponse{}
_, err = cs.client.Do(req, t)
if err != nil {
return nil, err
}
return t, err
} | go | {
"resource": ""
} |
q17826 | Update | train | func (cs *TeamService) Update(id int, team Team) (*TeamResponse, error) {
req, err := cs.client.NewRequest("PUT", "/teams/"+strconv.Itoa(id), team.PutParams())
if err != nil {
return nil, err
}
t := &TeamResponse{}
_, err = cs.client.Do(req, t)
if err != nil {
return nil, err
}
return t, err
} | go | {
"resource": ""
} |
q17827 | Delete | train | func (cs *TeamService) Delete(id int) (*TeamDeleteResponse, error) {
req, err := cs.client.NewRequest("DELETE", "/teams/"+strconv.Itoa(id), nil)
if err != nil {
return nil, err
}
t := &TeamDeleteResponse{}
_, err = cs.client.Do(req, t)
if err != nil {
return nil, err
}
return t, err
} | go | {
"resource": ""
} |
q17828 | PutParams | train | func (ck *MaintenanceWindow) PutParams() map[string]string {
m := map[string]string{
"description": ck.Description,
"from": strconv.FormatInt(ck.From, 10),
"to": strconv.FormatInt(ck.To, 10),
}
// Ignore if not defined
if ck.RecurrenceType != "" {
m["recurrencetype"] = ck.RecurrenceType
}
if ck.UptimeIDs != "" {
m["uptimeids"] = ck.UptimeIDs
}
if ck.TmsIDs != "" {
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
} | go | {
"resource": ""
} |
q17829 | Valid | train | func (ck *MaintenanceWindow) Valid() error {
if ck.Description == "" {
return fmt.Errorf("Invalid value for `Description`. Must contain non-empty string")
}
if ck.From == 0 {
return fmt.Errorf("Invalid value for `From`. Must contain time")
}
if ck.To == 0 {
return fmt.Errorf("Invalid value for `To`. Must contain time")
}
return nil
} | go | {
"resource": ""
} |
q17830 | DeleteParams | train | func (ck *MaintenanceWindowDelete) DeleteParams() map[string]string {
m := map[string]string{
"maintenanceids": ck.MaintenanceIDs,
}
return m
} | go | {
"resource": ""
} |
q17831 | List | train | func (cs *CheckService) List(params ...map[string]string) ([]CheckResponse, error) {
param := map[string]string{}
if len(params) == 1 {
param = params[0]
}
req, err := cs.client.NewRequest("GET", "/checks", param)
if err != nil {
return nil, err
}
resp, err := cs.client.client.Do(req)
if err != nil {
return nil, err
}
defer resp.Body.Close()
if err := validateResponse(resp); err != nil {
return nil, err
}
bodyBytes, _ := ioutil.ReadAll(resp.Body)
bodyString := string(bodyBytes)
m := &listChecksJSONResponse{}
err = json.Unmarshal([]byte(bodyString), &m)
return m.Checks, err
} | go | {
"resource": ""
} |
q17832 | Create | train | func (cs *CheckService) Create(check Check) (*CheckResponse, error) {
if err := check.Valid(); err != nil {
return nil, err
}
req, err := cs.client.NewRequest("POST", "/checks", check.PostParams())
if err != nil {
return nil, err
}
m := &checkDetailsJSONResponse{}
_, err = cs.client.Do(req, m)
if err != nil {
return nil, err
}
return m.Check, err
} | go | {
"resource": ""
} |
q17833 | Read | train | func (cs *CheckService) Read(id int) (*CheckResponse, error) {
req, err := cs.client.NewRequest("GET", "/checks/"+strconv.Itoa(id)+"?include_teams=true", nil)
if err != nil {
return nil, err
}
m := &checkDetailsJSONResponse{}
_, err = cs.client.Do(req, m)
if err != 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
} | go | {
"resource": ""
} |
q17834 | Update | train | func (cs *CheckService) Update(id int, check Check) (*PingdomResponse, error) {
if err := check.Valid(); err != nil {
return nil, err
}
req, err := cs.client.NewRequest("PUT", "/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
} | go | {
"resource": ""
} |
q17835 | Delete | train | func (cs *CheckService) Delete(id int) (*PingdomResponse, error) {
req, err := cs.client.NewRequest("DELETE", "/checks/"+strconv.Itoa(id), nil)
if err != nil {
return nil, err
}
m := &PingdomResponse{}
_, err = cs.client.Do(req, m)
if err != nil {
return nil, err
}
return m, err
} | go | {
"resource": ""
} |
q17836 | SummaryPerformance | train | func (cs *CheckService) SummaryPerformance(request SummaryPerformanceRequest) (*SummaryPerformanceResponse, error) {
if err := request.Valid(); err != nil {
return nil, err
}
req, err := cs.client.NewRequest("GET", "/summary.performance/"+strconv.Itoa(request.Id), request.GetParams())
if err != nil {
return nil, err
}
m := &SummaryPerformanceResponse{}
_, err = cs.client.Do(req, m)
if err != nil {
return nil, err
}
return m, nil
} | go | {
"resource": ""
} |
q17837 | NewClientWithConfig | train | func NewClientWithConfig(config ClientConfig) (*Client, error) {
var baseURL *url.URL
var err error
if config.BaseURL != "" {
baseURL, err = url.Parse(config.BaseURL)
} else {
baseURL, err = url.Parse(defaultBaseURL)
}
if err != nil {
return nil, err
}
c := &Client{
User: config.User,
Password: config.Password,
APIKey: config.APIKey,
AccountEmail: config.AccountEmail,
BaseURL: baseURL,
}
if config.HTTPClient != nil {
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}
return c, nil
} | go | {
"resource": ""
} |
q17838 | NewRequest | train | func (pc *Client) NewRequest(method string, rsc string, params map[string]string) (*http.Request, error) {
baseURL, err := url.Parse(pc.BaseURL.String() + rsc)
if err != nil {
return nil, err
}
if params != nil {
ps := url.Values{}
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, err
} | go | {
"resource": ""
} |
q17839 | Do | train | func (pc *Client) Do(req *http.Request, v interface{}) (*http.Response, error) {
resp, err := pc.client.Do(req)
if err != nil {
return nil, err
}
defer resp.Body.Close()
if err := validateResponse(resp); err != nil {
return resp, err
}
err = decodeResponse(resp, v)
return resp, err
} | go | {
"resource": ""
} |
q17840 | validateResponse | train | func validateResponse(r *http.Response) error {
if c := r.StatusCode; 200 <= c && c <= 299 {
return nil
}
bodyBytes, _ := ioutil.ReadAll(r.Body)
bodyString := string(bodyBytes)
m := &errorJSONResponse{}
err := json.Unmarshal([]byte(bodyString), &m)
if err != nil {
return err
}
return m.Error
} | go | {
"resource": ""
} |
q17841 | PutParams | train | func (ck *HttpCheck) PutParams() map[string]string {
m := map[string]string{
"name": ck.Name,
"host": ck.Hostname,
"resolution": strconv.Itoa(ck.Resolution),
"paused": strconv.FormatBool(ck.Paused),
"notifyagainevery": strconv.Itoa(ck.NotifyAgainEvery),
"notifywhenbackup": strconv.FormatBool(ck.NotifyWhenBackup),
"url": ck.Url,
"encryption": strconv.FormatBool(ck.Encryption),
"postdata": ck.PostData,
"integrationids": intListToCDString(ck.IntegrationIds),
"tags": ck.Tags,
"probe_filters": ck.ProbeFilters,
"userids": intListToCDString(ck.UserIds),
"teamids": intListToCDString(ck.TeamIds),
}
// Ignore zero values
if ck.Port != 0 {
m["port"] = strconv.Itoa(ck.Port)
}
if ck.SendNotificationWhenDown != 0 {
m["sendnotificationwhendown"] = strconv.Itoa(ck.SendNotificationWhenDown)
}
if ck.ResponseTimeThreshold != 0 {
m["responsetime_threshold"] = strconv.Itoa(ck.ResponseTimeThreshold)
}
// ShouldContain and ShouldNotContain are mutually exclusive.
// 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 headers []string
for k := range ck.RequestHeaders {
headers = append(headers, k)
}
sort.Strings(headers)
for i, k := range headers {
m[fmt.Sprintf("requestheader%d", i)] = fmt.Sprintf("%s:%s", k, ck.RequestHeaders[k])
}
return m
} | go | {
"resource": ""
} |
q17842 | PostParams | train | func (ck *HttpCheck) PostParams() map[string]string {
params := ck.PutParams()
for k, v := range params {
if v == "" {
delete(params, k)
}
}
params["type"] = "http"
return params
} | go | {
"resource": ""
} |
q17843 | Valid | train | func (ck *HttpCheck) Valid() error {
if ck.Name == "" {
return fmt.Errorf("Invalid value for `Name`. Must contain non-empty string")
}
if ck.Hostname == "" {
return fmt.Errorf("Invalid value for `Hostname`. Must contain non-empty string")
}
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.ShouldContain != "" && ck.ShouldNotContain != "" {
return fmt.Errorf("`ShouldContain` and `ShouldNotContain` must not be declared at the same time")
}
return nil
} | go | {
"resource": ""
} |
q17844 | PutParams | train | func (ck *PingCheck) PutParams() map[string]string {
m := map[string]string{
"name": ck.Name,
"host": ck.Hostname,
"resolution": strconv.Itoa(ck.Resolution),
"paused": strconv.FormatBool(ck.Paused),
"notifyagainevery": strconv.Itoa(ck.NotifyAgainEvery),
"notifywhenbackup": strconv.FormatBool(ck.NotifyWhenBackup),
"integrationids": intListToCDString(ck.IntegrationIds),
"probe_filters": ck.ProbeFilters,
"userids": intListToCDString(ck.UserIds),
"teamids": 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
} | go | {
"resource": ""
} |
q17845 | Valid | train | func (ck *PingCheck) Valid() error {
if ck.Name == "" {
return fmt.Errorf("Invalid value for `Name`. Must contain non-empty string")
}
if ck.Hostname == "" {
return fmt.Errorf("Invalid value for `Hostname`. Must contain non-empty string")
}
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)
}
return nil
} | go | {
"resource": ""
} |
q17846 | PutParams | train | func (ck *TCPCheck) PutParams() map[string]string {
m := map[string]string{
"name": ck.Name,
"host": ck.Hostname,
"resolution": strconv.Itoa(ck.Resolution),
"paused": strconv.FormatBool(ck.Paused),
"notifyagainevery": strconv.Itoa(ck.NotifyAgainEvery),
"notifywhenbackup": strconv.FormatBool(ck.NotifyWhenBackup),
"integrationids": intListToCDString(ck.IntegrationIds),
"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.SendNotificationWhenDown)
}
if ck.StringToSend != "" {
m["stringtosend"] = ck.StringToSend
}
if ck.StringToExpect != "" {
m["stringtoexpect"] = ck.StringToExpect
}
return m
} | go | {
"resource": ""
} |
q17847 | Valid | train | func (ck *TCPCheck) Valid() error {
if ck.Name == "" {
return fmt.Errorf("invalid value for `Name`, must contain non-empty string")
}
if ck.Hostname == "" {
return fmt.Errorf("invalid value for `Hostname`, must contain non-empty string")
}
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 >= 1")
}
return nil
} | go | {
"resource": ""
} |
q17848 | Valid | train | func (csr SummaryPerformanceRequest) Valid() error {
if csr.Id == 0 {
return ErrMissingId
}
if csr.Resolution != "" && csr.Resolution != "hour" && csr.Resolution != "day" && csr.Resolution != "week" {
return ErrBadResolution
}
return nil
} | go | {
"resource": ""
} |
q17849 | GetParams | train | func (csr SummaryPerformanceRequest) GetParams() (params map[string]string) {
params = make(map[string]string)
if csr.Resolution != "" {
params["resolution"] = csr.Resolution
}
if csr.IncludeUptime {
params["includeuptime"] = "true"
}
return
} | go | {
"resource": ""
} |
q17850 | matchDnsaddr | train | func matchDnsaddr(maddr ma.Multiaddr, trailer []ma.Multiaddr) bool {
parts := ma.Split(maddr)
if ma.Join(parts[len(parts)-len(trailer):]...).Equal(ma.Join(trailer...)) {
return true
}
return false
} | go | {
"resource": ""
} |
q17851 | DiscoverGateway | train | func DiscoverGateway() (NAT, error) {
select {
case nat := <-discoverUPNP_IG1():
return nat, nil
case nat := <-discoverUPNP_IG2():
return nat, nil
case nat := <-discoverUPNP_GenIGDev():
return nat, nil
case nat := <-discoverNATPMP():
return nat, nil
case <-time.After(10 * time.Second):
return nil, ErrNoNATFound
}
} | go | {
"resource": ""
} |
q17852 | Insert | train | func (IS *InvertedSuffix) Insert(Word, Result string, Data interface{}) {
Query := IS.Converter(Word)
low, high := IS.Search(Query)
for k := low; k < high; k++ {
if IS.Results[IS.WordIndex[k]] == Word {
IS.Values[IS.WordIndex[k]] = Data
return
}
}
i := len(IS.Words)
IS.Words = append(IS.Words, Query)
Length := len(Query)
IS.Results = append(IS.Results, Result)
IS.Values = append(IS.Values, Data)
for j := 0; j < Length; j++ {
k, _ := IS.Search(Query[j:])
IS.WordIndex = 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
}
} | go | {
"resource": ""
} |
q17853 | ErrorCorrect | train | func ErrorCorrect(Word []byte, AllowedBytes []byte) [][]byte {
results := make([][]byte, 0)
N := len(Word)
for i := 0; i < N; i++ {
t := Word[i]
// Remove Character
temp := make([]byte, N)
copy(temp, Word)
temp = append(temp[:i], temp[i+1:]...)
results = append(results, temp)
if i != 0 {
// Add Character
for _, c := range AllowedBytes {
temp := make([]byte, N)
copy(temp, Word)
temp = append(temp[:i], append([]byte{c}, temp[i:]...)...)
results = append(results, temp)
}
// 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 = append(results, temp)
}
}
return results
} | go | {
"resource": ""
} |
q17854 | ToASCII | train | func ToASCII(r rune) rune {
a, ok := UnicodeToASCII[r]
if ok {
return a
}
return r
} | go | {
"resource": ""
} |
q17855 | UnicodeToLowerASCII | train | func UnicodeToLowerASCII(s string) []byte {
return []byte(strings.Map(func(r rune) rune { return unicode.ToLower(ToASCII(r)) }, s))
} | go | {
"resource": ""
} |
q17856 | New | train | func New(
ip string,
selfNodeId types.NodeId,
genNumber uint64,
gossipIntervals types.GossipIntervals,
gossipVersion string,
clusterId string,
selfFailureDomain string,
) Gossiper {
g := new(proto.GossiperImpl)
g.Init(ip, selfNodeId, genNumber, gossipIntervals, gossipVersion, clusterId, selfFailureDomain)
return g
} | go | {
"resource": ""
} |
q17857 | NodeMeta | train | func (gd *GossipDelegate) NodeMeta(limit int) []byte {
msg := gd.MetaInfo()
msgBytes, _ := gd.convertToBytes(msg)
return msgBytes
} | go | {
"resource": ""
} |
q17858 | NotifyJoin | train | func (gd *GossipDelegate) NotifyJoin(node *memberlist.Node) {
// Ignore self NotifyJoin
nodeName := gd.parseMemberlistNodeName(node.Name)
if nodeName == gd.nodeId {
return
}
gd.updateGossipTs()
// NotifyAlive should remove a node from memberlist if the
// gossip version mismatches.
// Nevertheless we are doing an extra check here.
if err := gd.gossipChecks(node); err != nil {
gd.RemoveNode(types.NodeId(nodeName))
}
} | go | {
"resource": ""
} |
q17859 | NotifyLeave | train | func (gd *GossipDelegate) NotifyLeave(node *memberlist.Node) {
nodeName := gd.parseMemberlistNodeName(node.Name)
if nodeName == gd.nodeId {
gd.triggerStateEvent(types.SELF_LEAVE)
} else {
if gd.quorumProvider.Type() == types.QUORUM_PROVIDER_FAILURE_DOMAINS {
go func() {
isSuspect := gd.isClusterDomainSuspectDown(types.NodeId(nodeName))
if isSuspect {
gd.setNodeAsSuspectOffline(nodeName)
} else {
gd.setNodeOffline(nodeName)
}
}()
} else {
gd.setNodeOffline(nodeName)
}
}
gd.updateGossipTs()
return
} | go | {
"resource": ""
} |
q17860 | isClusterDomainSuspectDown | train | func (gd *GossipDelegate) isClusterDomainSuspectDown(nodeId types.NodeId) bool {
nodeInfo, err := gd.GetLocalNodeInfo(nodeId)
if err != nil {
// Node not found in our map
// No need of putting it as a suspect
// We will mark it as Offline immediately
return false
}
if !gd.quorumProvider.IsDomainActive(nodeInfo.ClusterDomain) {
// The node is already a part of inactive domain
// No need of putting it as a suspect
return false
}
nodeList := gd.getNodesFromClusterDomain(nodeInfo.ClusterDomain)
for fdNodeId, _ := range nodeList {
if fdNodeId == nodeId || types.NodeId(gd.nodeId) == nodeId {
// No need of pinging ourselves or the suspected node.
continue
}
// TODO: Check the current status of the node and do a ping
// only if it is not already marked offline
nodeInfo, err := gd.GetLocalNodeInfo(fdNodeId)
if err != nil {
// If we cannot find this node's entry in our map
// there is no point in pinging it
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 node (%v: %v) in failure"+
" domain %v failed: %v", fdNodeId, nodeInfo.Addr, nodeInfo.ClusterDomain, pingErr)
continue
} else {
// Ping to a node in the same cluster domain succeeded
// The cluster domain is online and only this node is offline
return false
}
}
// All the pings failed. The cluster domain is down. Put the node in suspect before marking it down.
return true
} | go | {
"resource": ""
} |
q17861 | NewProbationManager | train | func NewProbationManager(
name string,
probationTimeout time.Duration,
pcf CallbackFn,
) Probation {
if sched.Instance() == nil {
sched.Init(1 * time.Second)
}
p := &probation{
name: name,
probationTimeout: probationTimeout,
pcf: pcf,
probationTasks: make(map[string]sched.TaskID),
schedInst: sched.Instance(),
}
return p
} | go | {
"resource": ""
} |
q17862 | isDomainActive | train | func (f *failureDomainsQuorum) isDomainActive(ipDomain string) bool {
isActive, _ := f.activeMap[ipDomain]
if isActive == types.CLUSTER_DOMAIN_STATE_ACTIVE {
return true
}
return false
} | go | {
"resource": ""
} |
q17863 | NewQuorumProvider | train | func NewQuorumProvider(
selfId types.NodeId,
provider types.QuorumProvider,
) Quorum {
if provider == types.QUORUM_PROVIDER_DEFAULT {
return &defaultQuorum{
selfId: selfId,
}
}
return &failureDomainsQuorum{
selfId: selfId,
}
} | go | {
"resource": ""
} |
q17864 | computeRolloverTime | train | func (self *TimedRotatingFileHandler) computeRolloverTime(
currentTime time.Time) time.Time {
result := currentTime.Add(self.interval)
// If we are rolling over at midnight or weekly, then the interval is
// already known. What we need to figure out is WHEN the next interval is.
// In other words, if you are rolling over at midnight, then
// your base interval is 1 day, but you want to start that one day clock
// at midnight, not now.
// So, we have to fudge the rolloverTime value in order trigger the first
// rollover at the right time. After that, the regular interval will
// take care of the rest.
// Note that this code doesn't care about leap seconds.
if (self.when == "MIDNIGHT") || strings.HasPrefix(self.when, "W") {
var t time.Time
if self.utc {
t = currentTime.UTC()
} else {
t = currentTime.Local()
}
dayStartTime := time.Date(
t.Year(), t.Month(), t.Day(), 0, 0, 0, 0, t.Location())
result = currentTime.Add(Day - t.Sub(dayStartTime))
// If we are rolling over on a certain day, add in the number of days
// until the next rollover, but offset by 1 since we just calculated
// the time until the next day starts. There are three cases:
// Case 1) The day to rollover is today; in this case, do nothing
// Case 2) The day to rollover is further in the interval (i.e.,
// today is day 3 (Wednesday) and rollover is on day 6
// (Saturday). Days to next rollover is simply 6 - 3, or 3)
// Case 3) The day to rollover is behind us in the interval (i.e.,
// today is 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) and 3) above need to
// have a day added. This is because the above time calculation
// takes us to midnight on this day, i.e., the start of the next day.
if strings.HasPrefix(self.when, "W") {
weekday := int(t.Weekday())
if weekday != self.weekday {
var daysToWait int
if weekday < self.weekday {
daysToWait = self.weekday - weekday
} else {
daysToWait = 6 - weekday + self.weekday + 1
}
result = result.Add(time.Duration(int64(daysToWait) * int64(Day)))
// NOTE: we skip the daylight savings time issues here
// because time library in Golang doesn't support it.
}
}
}
return result
} | go | {
"resource": ""
} |
q17865 | ShouldRollover | train | func (self *TimedRotatingFileHandler) ShouldRollover(
record *LogRecord) (bool, string) {
overTime := time.Now().After(self.rolloverTime)
return overTime, self.Format(record)
} | go | {
"resource": ""
} |
q17866 | getFilesToDelete | train | func (self *TimedRotatingFileHandler) getFilesToDelete() ([]string, error) {
dirName, baseName := filepath.Split(self.GetFilePath())
fileInfos, err := ioutil.ReadDir(dirName)
if err != nil {
return nil, err
}
prefix := baseName + "."
pattern, err := regexp.Compile(self.extMatch)
if err != nil {
return nil, err
}
var fileNames []string
for _, info := range fileInfos {
fileName := info.Name()
if strings.HasPrefix(fileName, prefix) {
suffix := fileName[len(prefix):]
if pattern.MatchString(suffix) {
fileNames = append(fileNames, fileName)
}
}
}
// 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])
}
return result, nil
} | go | {
"resource": ""
} |
q17867 | Emit | train | func (self *SyslogHandler) Emit(record *LogRecord) error {
message := self.BaseHandler.Format(record)
var err error
switch record.Level {
case LevelFatal:
err = self.writer.Crit(message)
case LevelError:
err = self.writer.Err(message)
case LevelWarn:
err = self.writer.Warning(message)
case LevelInfo:
err = self.writer.Info(message)
case LevelDebug:
err = self.writer.Debug(message)
default:
_, err = self.writer.Write([]byte(message))
}
return err
} | go | {
"resource": ""
} |
q17868 | NewBaseRotatingHandler | train | func NewBaseRotatingHandler(
filepath string, mode, bufferSize int) (*BaseRotatingHandler, error) {
fileHandler, err := NewFileHandler(filepath, mode, bufferSize)
if err != nil {
return nil, err
}
object := &BaseRotatingHandler{
FileHandler: fileHandler,
}
Closer.RemoveHandler(object.FileHandler)
Closer.AddHandler(object)
return object, nil
} | go | {
"resource": ""
} |
q17869 | RolloverEmit | train | func (self *BaseRotatingHandler) RolloverEmit(
handler RotatingHandler, record *LogRecord) error {
// We don't use the implementation of StreamHandler.Emit2() but directly
// write to stream here in order to avoid calling self.Format() twice
// for performance optimization.
doRollover, message := handler.ShouldRollover(record)
if doRollover {
if err := handler.Flush(); err != nil {
return err
}
if err := handler.DoRollover(); err != nil {
return err
}
}
// Message already has a trailing '\n'.
err := self.GetStream().Write(message)
if err != nil {
return err
}
return nil
} | go | {
"resource": ""
} |
q17870 | ShouldRollover | train | func (self *RotatingFileHandler) ShouldRollover(
record *LogRecord) (bool, string) {
message := self.Format(record)
if self.maxBytes > 0 {
offset, err := self.GetStream().Tell()
if err != nil {
// don't trigger rollover action if we lose offset info
return false, message
}
if (uint64(offset) + uint64(len(message))) > self.maxBytes {
return true, message
}
}
return false, message
} | go | {
"resource": ""
} |
q17871 | RotateFile | train | func (self *RotatingFileHandler) RotateFile(sourceFile, destFile string) error {
if FileExists(sourceFile) {
if FileExists(destFile) {
if err := os.Remove(destFile); err != nil {
return err
}
}
if err := os.Rename(sourceFile, destFile); err != nil {
return err
}
}
return nil
} | go | {
"resource": ""
} |
q17872 | DoRollover | train | func (self *RotatingFileHandler) DoRollover() (err error) {
self.FileHandler.Close()
defer func() {
if e := self.FileHandler.Open(); e != nil {
if e == nil {
err = e
}
}
}()
if self.backupCount > 0 {
filepath := self.GetFilePath()
for i := 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, destFile); err != nil {
return err
}
}
return nil
} | go | {
"resource": ""
} |
q17873 | NewSocketHandler | train | func NewSocketHandler(host string, port uint16) *SocketHandler {
retry := NewErrorRetry().
Delay(SocketDefaultDelay).
Deadline(SocketDefaultMaxDeadline)
object := &SocketHandler{
BaseHandler: NewBaseHandler("", LevelNotset),
host: host,
port: port,
closeOnError: true,
retry: retry,
}
object.makeConnFunc = object.makeTCPSocket
object.sendFunc = object.sendTCP
Closer.AddHandler(object)
return object
} | go | {
"resource": ""
} |
q17874 | Marshal | train | func (self *SocketHandler) Marshal(record *LogRecord) ([]byte, error) {
r := SocketLogRecord{
CreatedTime: record.CreatedTime,
AscTime: record.AscTime,
Name: record.Name,
Level: record.Level,
PathName: record.PathName,
FileName: record.FileName,
LineNo: record.LineNo,
FuncName: record.FuncName,
Format: record.Format,
UseFormat: 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
} | go | {
"resource": ""
} |
q17875 | makeSocket | train | func (self *SocketHandler) makeSocket(network string) error {
address := fmt.Sprintf("%s:%d", self.host, self.port)
conn, err := net.DialTimeout(network, address, SocketDefaultTimeout)
if err != nil {
return err
}
self.conn = conn
return nil
} | go | {
"resource": ""
} |
q17876 | sendTCP | train | func (self *SocketHandler) sendTCP(bin []byte) error {
if self.conn == nil {
err := self.createSocket()
if err != nil {
return err
}
}
sentSoFar, left := 0, len(bin)
for left > 0 {
sent, err := self.conn.Write(bin[sentSoFar:])
if err != nil {
return err
}
sentSoFar += sent
left -= sent
}
return nil
} | go | {
"resource": ""
} |
q17877 | sendUDP | train | func (self *SocketHandler) sendUDP(bin []byte) error {
if self.conn == nil {
err := self.createSocket()
if err != nil {
return err
}
}
_, err := self.conn.Write(bin)
return err
} | go | {
"resource": ""
} |
q17878 | Emit | train | func (self *SocketHandler) Emit(record *LogRecord) error {
self.Format(record)
bin, err := self.Marshal(record)
if err != nil {
return err
}
return self.sendFunc(bin)
} | go | {
"resource": ""
} |
q17879 | HandleError | train | func (self *SocketHandler) HandleError(record *LogRecord, err error) {
if self.closeOnError && (self.conn != nil) {
self.conn.Close()
self.conn = nil
} else {
self.BaseHandler.HandleError(record, err)
}
} | go | {
"resource": ""
} |
q17880 | Close | train | func (self *SocketHandler) Close() {
self.Lock()
defer self.Unlock()
if self.conn != nil {
self.conn.Close()
self.conn = nil
}
self.BaseHandler.Close()
} | go | {
"resource": ""
} |
q17881 | Filter | train | func (self *NameFilter) Filter(record *LogRecord) bool {
length := len(self.name)
if length == 0 {
return true
} else if self.name == record.Name {
return true
} else if !strings.HasPrefix(record.Name, self.name) {
return false
}
return (record.Name[length] == '.')
} | go | {
"resource": ""
} |
q17882 | AddFilter | train | func (self *StandardFilterer) AddFilter(filter Filter) {
if !self.filters.SetContains(filter) {
self.filters.SetAdd(filter)
}
} | go | {
"resource": ""
} |
q17883 | RemoveFilter | train | func (self *StandardFilterer) RemoveFilter(filter Filter) {
if self.filters.SetContains(filter) {
self.filters.SetRemove(filter)
}
} | go | {
"resource": ""
} |
q17884 | GetLogger | train | func GetLogger(name string) Logger {
if len(name) > 0 {
return manager.GetLogger(name)
} else {
return root
}
} | go | {
"resource": ""
} |
q17885 | Logf | train | func Logf(level LogLevelType, format string, args ...interface{}) {
root.Logf(level, format, args...)
} | go | {
"resource": ""
} |
q17886 | NewFileHandler | train | func NewFileHandler(filename string, mode int, bufferSize int) (*FileHandler, error) {
// keep the absolute path, otherwise derived classes which use this
// may come a cropper when the current directory changes.
filepath, err := filepath.Abs(filename)
if err != nil {
return nil, err
}
handler := NewStreamHandler(filepath, LevelNotset, nil)
object := &FileHandler{
StreamHandler: handler,
filepath: filepath,
mode: mode,
bufferSize: bufferSize,
}
if err = object.Open(); err != nil {
return nil, err
}
Closer.RemoveHandler(object.StreamHandler)
Closer.AddHandler(object)
return object, nil
} | go | {
"resource": ""
} |
q17887 | ApplyConfigFile | train | func ApplyConfigFile(file string) error {
ext := filepath.Ext(file)
switch ext {
case ".json":
return ApplyJsonConfigFile(file)
case ".yml":
fallthrough
case ".yaml":
return ApplyYAMLConfigFile(file)
default:
return errors.New(fmt.Sprintf(
"unknown format of the specified file: %s", file))
}
} | go | {
"resource": ""
} |
q17888 | ApplyJsonConfigFile | train | func ApplyJsonConfigFile(file string) error {
bin, err := ioutil.ReadFile(file)
if err != nil {
return err
}
decoder := json.NewDecoder(bytes.NewBuffer(bin))
decoder.UseNumber()
var conf Conf
if err = decoder.Decode(&conf); err != nil {
return err
}
return DictConfig(&conf)
} | go | {
"resource": ""
} |
q17889 | ApplyYAMLConfigFile | train | func ApplyYAMLConfigFile(file string) error {
bin, err := ioutil.ReadFile(file)
if err != nil {
return err
}
var conf Conf
if err = yaml.Unmarshal(bin, &conf); err != nil {
return err
}
return DictConfig(&conf)
} | go | {
"resource": ""
} |
q17890 | NewBaseHandler | train | func NewBaseHandler(name string, level LogLevelType) *BaseHandler {
return &BaseHandler{
StandardFilterer: NewStandardFilterer(),
name: name,
level: level,
formatter: nil,
}
} | go | {
"resource": ""
} |
q17891 | Format | train | func (self *BaseHandler) Format(record *LogRecord) string {
self.formatterLock.RLock()
defer self.formatterLock.RUnlock()
var formatter Formatter
if self.formatter != nil {
formatter = self.formatter
} else {
formatter = defaultFormatter
}
return formatter.Format(record)
} | go | {
"resource": ""
} |
q17892 | AddLevel | train | func AddLevel(level LogLevelType, levelName string) {
levelLock.Lock()
defer levelLock.Unlock()
levelToNames[level] = levelName
nameToLevels[levelName] = level
} | go | {
"resource": ""
} |
q17893 | NewPlaceHolder | train | func NewPlaceHolder(logger Logger) *PlaceHolder {
object := &PlaceHolder{
Loggers: NewListSet(),
}
object.Append(logger)
return object
} | go | {
"resource": ""
} |
q17894 | Append | train | func (self *PlaceHolder) Append(logger Logger) {
if !self.Loggers.SetContains(logger) {
self.Loggers.SetAdd(logger)
}
} | go | {
"resource": ""
} |
q17895 | findCaller | train | func findCaller() *CallerInfo {
for i := 3; ; i++ {
pc, filepath, line, ok := runtime.Caller(i)
if !ok {
return UnknownCallerInfo
}
parts := strings.Split(filepath, "/")
dir := parts[len(parts)-2]
file := parts[len(parts)-1]
if (dir != thisPackageName) || (file != thisFileName) {
funcName := runtime.FuncForPC(pc).Name()
return &CallerInfo{
PathName: filepath,
FileName: file,
LineNo: uint32(line),
FuncName: funcName,
}
}
}
} | go | {
"resource": ""
} |
q17896 | NewStandardLogger | train | func NewStandardLogger(name string, level LogLevelType) *StandardLogger {
object := &StandardLogger{
StandardFilterer: NewStandardFilterer(),
parent: nil,
name: name,
findCallerFunc: findCaller,
level: level,
propagate: true,
handlers: NewListSet(),
manager: nil,
}
return object
} | go | {
"resource": ""
} |
q17897 | GetEffectiveLevel | train | func (self *StandardLogger) GetEffectiveLevel() LogLevelType {
self.lock.RLock()
defer self.lock.RUnlock()
var logger Logger = self
for logger != nil {
level := logger.GetLevel()
if level != LevelNotset {
return level
}
logger = logger.GetParent()
}
return LevelNotset
} | go | {
"resource": ""
} |
q17898 | traverseHandlers | train | func (self *StandardLogger) traverseHandlers(record *LogRecord) {
var call Logger = self
for call != nil {
call.CallHandlers(record)
if !call.GetPropagate() {
call = nil
} else {
call = call.GetParent()
}
}
} | go | {
"resource": ""
} |
q17899 | NewRootLogger | train | func NewRootLogger(level LogLevelType) *RootLogger {
logger := NewStandardLogger("root", level)
logger.SetPropagate(false)
return &RootLogger{
StandardLogger: logger,
}
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.