id
int32 0
167k
| repo
stringlengths 5
54
| path
stringlengths 4
155
| func_name
stringlengths 1
118
| original_string
stringlengths 52
85.5k
| language
stringclasses 1
value | code
stringlengths 52
85.5k
| code_tokens
listlengths 21
1.41k
| docstring
stringlengths 6
2.61k
| docstring_tokens
listlengths 3
215
| sha
stringlengths 40
40
| url
stringlengths 85
252
|
|---|---|---|---|---|---|---|---|---|---|---|---|
17,800 |
likexian/whois-parser-go
|
utils.go
|
FixNameServers
|
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
|
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, ",")
}
|
[
"func",
"FixNameServers",
"(",
"nservers",
"string",
")",
"string",
"{",
"servers",
":=",
"strings",
".",
"Split",
"(",
"nservers",
",",
"\"",
"\"",
")",
"\n",
"for",
"k",
",",
"v",
":=",
"range",
"servers",
"{",
"names",
":=",
"strings",
".",
"Split",
"(",
"strings",
".",
"TrimSpace",
"(",
"v",
")",
",",
"\"",
"\"",
")",
"\n",
"servers",
"[",
"k",
"]",
"=",
"strings",
".",
"Trim",
"(",
"names",
"[",
"0",
"]",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"return",
"strings",
".",
"Join",
"(",
"servers",
",",
"\"",
"\"",
")",
"\n",
"}"
] |
// FixNameServers returns fixed name servers
|
[
"FixNameServers",
"returns",
"fixed",
"name",
"servers"
] |
0aa0498833b2f39c0a4f0ac0f6b5ddcf605fcf87
|
https://github.com/likexian/whois-parser-go/blob/0aa0498833b2f39c0a4f0ac0f6b5ddcf605fcf87/utils.go#L116-L124
|
17,801 |
russellcardullo/go-pingdom
|
pingdom/api_responses.go
|
UnmarshalJSON
|
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
|
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
}
|
[
"func",
"(",
"c",
"*",
"CheckResponseType",
")",
"UnmarshalJSON",
"(",
"b",
"[",
"]",
"byte",
")",
"error",
"{",
"var",
"raw",
"interface",
"{",
"}",
"\n\n",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"b",
",",
"&",
"raw",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"switch",
"v",
":=",
"raw",
".",
"(",
"type",
")",
"{",
"case",
"string",
":",
"c",
".",
"Name",
"=",
"v",
"\n",
"case",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
":",
"if",
"len",
"(",
"v",
")",
"!=",
"1",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"v",
")",
"\n",
"}",
"\n",
"for",
"k",
":=",
"range",
"v",
"{",
"c",
".",
"Name",
"=",
"k",
"\n",
"}",
"\n\n",
"// Allow continue use json.Unmarshall using a type != Unmarshaller",
"// This avoid enter in a infinite loop",
"type",
"t",
"CheckResponseType",
"\n",
"var",
"rawCheckDetails",
"t",
"\n\n",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"b",
",",
"&",
"rawCheckDetails",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"c",
".",
"HTTP",
"=",
"rawCheckDetails",
".",
"HTTP",
"\n",
"c",
".",
"TCP",
"=",
"rawCheckDetails",
".",
"TCP",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// UnmarshalJSON converts a byte array into a CheckResponseType.
|
[
"UnmarshalJSON",
"converts",
"a",
"byte",
"array",
"into",
"a",
"CheckResponseType",
"."
] |
017c8281f6d1a98515f8575e5152e02f545a5553
|
https://github.com/russellcardullo/go-pingdom/blob/017c8281f6d1a98515f8575e5152e02f545a5553/pingdom/api_responses.go#L178-L210
|
17,802 |
russellcardullo/go-pingdom
|
pingdom/api_responses.go
|
Error
|
func (r *PingdomError) Error() string {
return fmt.Sprintf("%d %v: %v", r.StatusCode, r.StatusDesc, r.Message)
}
|
go
|
func (r *PingdomError) Error() string {
return fmt.Sprintf("%d %v: %v", r.StatusCode, r.StatusDesc, r.Message)
}
|
[
"func",
"(",
"r",
"*",
"PingdomError",
")",
"Error",
"(",
")",
"string",
"{",
"return",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"r",
".",
"StatusCode",
",",
"r",
".",
"StatusDesc",
",",
"r",
".",
"Message",
")",
"\n",
"}"
] |
// Return string representation of the PingdomError.
|
[
"Return",
"string",
"representation",
"of",
"the",
"PingdomError",
"."
] |
017c8281f6d1a98515f8575e5152e02f545a5553
|
https://github.com/russellcardullo/go-pingdom/blob/017c8281f6d1a98515f8575e5152e02f545a5553/pingdom/api_responses.go#L233-L235
|
17,803 |
russellcardullo/go-pingdom
|
pingdom/public_report.go
|
List
|
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
|
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
}
|
[
"func",
"(",
"cs",
"*",
"PublicReportService",
")",
"List",
"(",
")",
"(",
"[",
"]",
"PublicReportResponse",
",",
"error",
")",
"{",
"req",
",",
"err",
":=",
"cs",
".",
"client",
".",
"NewRequest",
"(",
"\"",
"\"",
",",
"\"",
"\"",
",",
"nil",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"resp",
",",
"err",
":=",
"cs",
".",
"client",
".",
"client",
".",
"Do",
"(",
"req",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"defer",
"resp",
".",
"Body",
".",
"Close",
"(",
")",
"\n\n",
"if",
"err",
":=",
"validateResponse",
"(",
"resp",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"bodyBytes",
",",
"_",
":=",
"ioutil",
".",
"ReadAll",
"(",
"resp",
".",
"Body",
")",
"\n",
"bodyString",
":=",
"string",
"(",
"bodyBytes",
")",
"\n\n",
"t",
":=",
"&",
"listPublicReportsJSONResponse",
"{",
"}",
"\n",
"err",
"=",
"json",
".",
"Unmarshal",
"(",
"[",
"]",
"byte",
"(",
"bodyString",
")",
",",
"&",
"t",
")",
"\n\n",
"return",
"t",
".",
"Checks",
",",
"err",
"\n",
"}"
] |
// List return a list of reports from Pingdom.
|
[
"List",
"return",
"a",
"list",
"of",
"reports",
"from",
"Pingdom",
"."
] |
017c8281f6d1a98515f8575e5152e02f545a5553
|
https://github.com/russellcardullo/go-pingdom/blob/017c8281f6d1a98515f8575e5152e02f545a5553/pingdom/public_report.go#L15-L38
|
17,804 |
russellcardullo/go-pingdom
|
pingdom/public_report.go
|
PublishCheck
|
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
|
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
}
|
[
"func",
"(",
"cs",
"*",
"PublicReportService",
")",
"PublishCheck",
"(",
"id",
"int",
")",
"(",
"*",
"PingdomResponse",
",",
"error",
")",
"{",
"req",
",",
"err",
":=",
"cs",
".",
"client",
".",
"NewRequest",
"(",
"\"",
"\"",
",",
"\"",
"\"",
"+",
"strconv",
".",
"Itoa",
"(",
"id",
")",
",",
"nil",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"t",
":=",
"&",
"PingdomResponse",
"{",
"}",
"\n",
"_",
",",
"err",
"=",
"cs",
".",
"client",
".",
"Do",
"(",
"req",
",",
"t",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"t",
",",
"err",
"\n",
"}"
] |
// PublishCheck is used to activate a check on the public report.
|
[
"PublishCheck",
"is",
"used",
"to",
"activate",
"a",
"check",
"on",
"the",
"public",
"report",
"."
] |
017c8281f6d1a98515f8575e5152e02f545a5553
|
https://github.com/russellcardullo/go-pingdom/blob/017c8281f6d1a98515f8575e5152e02f545a5553/pingdom/public_report.go#L41-L53
|
17,805 |
russellcardullo/go-pingdom
|
pingdom/team_types.go
|
PutParams
|
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
|
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
}
|
[
"func",
"(",
"ck",
"*",
"TeamData",
")",
"PutParams",
"(",
")",
"map",
"[",
"string",
"]",
"string",
"{",
"t",
":=",
"map",
"[",
"string",
"]",
"string",
"{",
"\"",
"\"",
":",
"ck",
".",
"Name",
",",
"}",
"\n\n",
"// Ignore if not defined",
"if",
"ck",
".",
"UserIds",
"!=",
"\"",
"\"",
"{",
"t",
"[",
"\"",
"\"",
"]",
"=",
"ck",
".",
"UserIds",
"\n",
"}",
"\n\n",
"return",
"t",
"\n",
"}"
] |
// PutParams returns a map of parameters for an Team that can be sent along.
|
[
"PutParams",
"returns",
"a",
"map",
"of",
"parameters",
"for",
"an",
"Team",
"that",
"can",
"be",
"sent",
"along",
"."
] |
017c8281f6d1a98515f8575e5152e02f545a5553
|
https://github.com/russellcardullo/go-pingdom/blob/017c8281f6d1a98515f8575e5152e02f545a5553/pingdom/team_types.go#L14-L25
|
17,806 |
russellcardullo/go-pingdom
|
pingdom/probe.go
|
List
|
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
|
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
}
|
[
"func",
"(",
"cs",
"*",
"ProbeService",
")",
"List",
"(",
"params",
"...",
"map",
"[",
"string",
"]",
"string",
")",
"(",
"[",
"]",
"ProbeResponse",
",",
"error",
")",
"{",
"param",
":=",
"map",
"[",
"string",
"]",
"string",
"{",
"}",
"\n",
"if",
"len",
"(",
"params",
")",
"==",
"1",
"{",
"param",
"=",
"params",
"[",
"0",
"]",
"\n",
"}",
"\n",
"req",
",",
"err",
":=",
"cs",
".",
"client",
".",
"NewRequest",
"(",
"\"",
"\"",
",",
"\"",
"\"",
",",
"param",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"resp",
",",
"err",
":=",
"cs",
".",
"client",
".",
"client",
".",
"Do",
"(",
"req",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"defer",
"resp",
".",
"Body",
".",
"Close",
"(",
")",
"\n\n",
"if",
"err",
":=",
"validateResponse",
"(",
"resp",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"bodyBytes",
",",
"_",
":=",
"ioutil",
".",
"ReadAll",
"(",
"resp",
".",
"Body",
")",
"\n",
"bodyString",
":=",
"string",
"(",
"bodyBytes",
")",
"\n\n",
"p",
":=",
"&",
"listProbesJSONResponse",
"{",
"}",
"\n",
"err",
"=",
"json",
".",
"Unmarshal",
"(",
"[",
"]",
"byte",
"(",
"bodyString",
")",
",",
"&",
"p",
")",
"\n\n",
"return",
"p",
".",
"Probes",
",",
"err",
"\n",
"}"
] |
// List return a list of probes from Pingdom.
|
[
"List",
"return",
"a",
"list",
"of",
"probes",
"from",
"Pingdom",
"."
] |
017c8281f6d1a98515f8575e5152e02f545a5553
|
https://github.com/russellcardullo/go-pingdom/blob/017c8281f6d1a98515f8575e5152e02f545a5553/pingdom/probe.go#L14-L41
|
17,807 |
russellcardullo/go-pingdom
|
pingdom/user_types.go
|
ValidContact
|
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
|
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
}
|
[
"func",
"(",
"c",
"*",
"Contact",
")",
"ValidContact",
"(",
")",
"error",
"{",
"if",
"c",
".",
"Email",
"==",
"\"",
"\"",
"&&",
"c",
".",
"Number",
"==",
"\"",
"\"",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"if",
"c",
".",
"Number",
"!=",
"\"",
"\"",
"&&",
"c",
".",
"CountryCode",
"==",
"\"",
"\"",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"if",
"c",
".",
"Provider",
"!=",
"\"",
"\"",
"&&",
"(",
"c",
".",
"Number",
"==",
"\"",
"\"",
"||",
"c",
".",
"CountryCode",
"==",
"\"",
"\"",
")",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] |
// ValidContact determines whether a Contact contains valid fields.
|
[
"ValidContact",
"determines",
"whether",
"a",
"Contact",
"contains",
"valid",
"fields",
"."
] |
017c8281f6d1a98515f8575e5152e02f545a5553
|
https://github.com/russellcardullo/go-pingdom/blob/017c8281f6d1a98515f8575e5152e02f545a5553/pingdom/user_types.go#L49-L63
|
17,808 |
russellcardullo/go-pingdom
|
pingdom/user_types.go
|
PostParams
|
func (u *User) PostParams() map[string]string {
m := map[string]string{
"name": u.Username,
}
return m
}
|
go
|
func (u *User) PostParams() map[string]string {
m := map[string]string{
"name": u.Username,
}
return m
}
|
[
"func",
"(",
"u",
"*",
"User",
")",
"PostParams",
"(",
")",
"map",
"[",
"string",
"]",
"string",
"{",
"m",
":=",
"map",
"[",
"string",
"]",
"string",
"{",
"\"",
"\"",
":",
"u",
".",
"Username",
",",
"}",
"\n\n",
"return",
"m",
"\n",
"}"
] |
// PostParams returns a map of params that are sent with an HTTP POST request for a User.
|
[
"PostParams",
"returns",
"a",
"map",
"of",
"params",
"that",
"are",
"sent",
"with",
"an",
"HTTP",
"POST",
"request",
"for",
"a",
"User",
"."
] |
017c8281f6d1a98515f8575e5152e02f545a5553
|
https://github.com/russellcardullo/go-pingdom/blob/017c8281f6d1a98515f8575e5152e02f545a5553/pingdom/user_types.go#L66-L72
|
17,809 |
russellcardullo/go-pingdom
|
pingdom/user_types.go
|
PostContactParams
|
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
|
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
}
|
[
"func",
"(",
"c",
"*",
"Contact",
")",
"PostContactParams",
"(",
")",
"map",
"[",
"string",
"]",
"string",
"{",
"m",
":=",
"map",
"[",
"string",
"]",
"string",
"{",
"}",
"\n\n",
"// Ignore if not defined",
"if",
"c",
".",
"Email",
"!=",
"\"",
"\"",
"{",
"m",
"[",
"\"",
"\"",
"]",
"=",
"c",
".",
"Email",
"\n",
"}",
"\n\n",
"if",
"c",
".",
"Number",
"!=",
"\"",
"\"",
"{",
"m",
"[",
"\"",
"\"",
"]",
"=",
"c",
".",
"Number",
"\n",
"}",
"\n\n",
"if",
"c",
".",
"CountryCode",
"!=",
"\"",
"\"",
"{",
"m",
"[",
"\"",
"\"",
"]",
"=",
"c",
".",
"CountryCode",
"\n",
"}",
"\n\n",
"if",
"c",
".",
"Severity",
"!=",
"\"",
"\"",
"{",
"m",
"[",
"\"",
"\"",
"]",
"=",
"c",
".",
"Severity",
"\n",
"}",
"\n\n",
"if",
"c",
".",
"Provider",
"!=",
"\"",
"\"",
"{",
"m",
"[",
"\"",
"\"",
"]",
"=",
"c",
".",
"Provider",
"\n",
"}",
"\n\n",
"return",
"m",
"\n",
"}"
] |
// PostContactParams returns a map of params that are sent with an HTTP POST request for a Contact.
|
[
"PostContactParams",
"returns",
"a",
"map",
"of",
"params",
"that",
"are",
"sent",
"with",
"an",
"HTTP",
"POST",
"request",
"for",
"a",
"Contact",
"."
] |
017c8281f6d1a98515f8575e5152e02f545a5553
|
https://github.com/russellcardullo/go-pingdom/blob/017c8281f6d1a98515f8575e5152e02f545a5553/pingdom/user_types.go#L75-L100
|
17,810 |
russellcardullo/go-pingdom
|
pingdom/user_types.go
|
PutParams
|
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
|
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
}
|
[
"func",
"(",
"u",
"*",
"User",
")",
"PutParams",
"(",
")",
"map",
"[",
"string",
"]",
"string",
"{",
"m",
":=",
"map",
"[",
"string",
"]",
"string",
"{",
"\"",
"\"",
":",
"u",
".",
"Username",
",",
"}",
"\n\n",
"if",
"u",
".",
"Primary",
"!=",
"\"",
"\"",
"{",
"m",
"[",
"\"",
"\"",
"]",
"=",
"u",
".",
"Primary",
"\n",
"}",
"\n\n",
"if",
"u",
".",
"Paused",
"!=",
"\"",
"\"",
"{",
"m",
"[",
"\"",
"\"",
"]",
"=",
"u",
".",
"Paused",
"\n",
"}",
"\n\n",
"return",
"m",
"\n",
"}"
] |
// PutParams returns a map of params that are sent with an HTTP PUT request for a User.
|
[
"PutParams",
"returns",
"a",
"map",
"of",
"params",
"that",
"are",
"sent",
"with",
"an",
"HTTP",
"PUT",
"request",
"for",
"a",
"User",
"."
] |
017c8281f6d1a98515f8575e5152e02f545a5553
|
https://github.com/russellcardullo/go-pingdom/blob/017c8281f6d1a98515f8575e5152e02f545a5553/pingdom/user_types.go#L103-L117
|
17,811 |
russellcardullo/go-pingdom
|
pingdom/maintenance.go
|
List
|
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
|
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
}
|
[
"func",
"(",
"cs",
"*",
"MaintenanceService",
")",
"List",
"(",
"params",
"...",
"map",
"[",
"string",
"]",
"string",
")",
"(",
"[",
"]",
"MaintenanceResponse",
",",
"error",
")",
"{",
"param",
":=",
"map",
"[",
"string",
"]",
"string",
"{",
"}",
"\n",
"if",
"len",
"(",
"params",
")",
"!=",
"0",
"{",
"for",
"_",
",",
"m",
":=",
"range",
"params",
"{",
"for",
"k",
",",
"v",
":=",
"range",
"m",
"{",
"param",
"[",
"k",
"]",
"=",
"v",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"req",
",",
"err",
":=",
"cs",
".",
"client",
".",
"NewRequest",
"(",
"\"",
"\"",
",",
"\"",
"\"",
",",
"param",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"resp",
",",
"err",
":=",
"cs",
".",
"client",
".",
"client",
".",
"Do",
"(",
"req",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"defer",
"resp",
".",
"Body",
".",
"Close",
"(",
")",
"\n\n",
"if",
"err",
":=",
"validateResponse",
"(",
"resp",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"bodyBytes",
",",
"_",
":=",
"ioutil",
".",
"ReadAll",
"(",
"resp",
".",
"Body",
")",
"\n",
"bodyString",
":=",
"string",
"(",
"bodyBytes",
")",
"\n\n",
"m",
":=",
"&",
"listMaintenanceJSONResponse",
"{",
"}",
"\n",
"err",
"=",
"json",
".",
"Unmarshal",
"(",
"[",
"]",
"byte",
"(",
"bodyString",
")",
",",
"&",
"m",
")",
"\n\n",
"return",
"m",
".",
"Maintenances",
",",
"err",
"\n",
"}"
] |
// List returns the response holding a list of Maintenance windows.
|
[
"List",
"returns",
"the",
"response",
"holding",
"a",
"list",
"of",
"Maintenance",
"windows",
"."
] |
017c8281f6d1a98515f8575e5152e02f545a5553
|
https://github.com/russellcardullo/go-pingdom/blob/017c8281f6d1a98515f8575e5152e02f545a5553/pingdom/maintenance.go#L28-L59
|
17,812 |
russellcardullo/go-pingdom
|
pingdom/maintenance.go
|
Read
|
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
|
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
}
|
[
"func",
"(",
"cs",
"*",
"MaintenanceService",
")",
"Read",
"(",
"id",
"int",
")",
"(",
"*",
"MaintenanceResponse",
",",
"error",
")",
"{",
"req",
",",
"err",
":=",
"cs",
".",
"client",
".",
"NewRequest",
"(",
"\"",
"\"",
",",
"\"",
"\"",
"+",
"strconv",
".",
"Itoa",
"(",
"id",
")",
",",
"nil",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"m",
":=",
"&",
"maintenanceDetailsJSONResponse",
"{",
"}",
"\n",
"_",
",",
"err",
"=",
"cs",
".",
"client",
".",
"Do",
"(",
"req",
",",
"m",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"m",
".",
"Maintenance",
",",
"err",
"\n",
"}"
] |
// Read returns a Maintenance for a given ID.
|
[
"Read",
"returns",
"a",
"Maintenance",
"for",
"a",
"given",
"ID",
"."
] |
017c8281f6d1a98515f8575e5152e02f545a5553
|
https://github.com/russellcardullo/go-pingdom/blob/017c8281f6d1a98515f8575e5152e02f545a5553/pingdom/maintenance.go#L62-L75
|
17,813 |
russellcardullo/go-pingdom
|
pingdom/maintenance.go
|
Create
|
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
|
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
}
|
[
"func",
"(",
"cs",
"*",
"MaintenanceService",
")",
"Create",
"(",
"maintenance",
"Maintenance",
")",
"(",
"*",
"MaintenanceResponse",
",",
"error",
")",
"{",
"if",
"err",
":=",
"maintenance",
".",
"Valid",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"req",
",",
"err",
":=",
"cs",
".",
"client",
".",
"NewRequest",
"(",
"\"",
"\"",
",",
"\"",
"\"",
",",
"maintenance",
".",
"PostParams",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"m",
":=",
"&",
"maintenanceDetailsJSONResponse",
"{",
"}",
"\n",
"_",
",",
"err",
"=",
"cs",
".",
"client",
".",
"Do",
"(",
"req",
",",
"m",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"m",
".",
"Maintenance",
",",
"err",
"\n",
"}"
] |
// Create creates a new Maintenance.
|
[
"Create",
"creates",
"a",
"new",
"Maintenance",
"."
] |
017c8281f6d1a98515f8575e5152e02f545a5553
|
https://github.com/russellcardullo/go-pingdom/blob/017c8281f6d1a98515f8575e5152e02f545a5553/pingdom/maintenance.go#L78-L94
|
17,814 |
russellcardullo/go-pingdom
|
pingdom/maintenance.go
|
Update
|
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
|
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
}
|
[
"func",
"(",
"cs",
"*",
"MaintenanceService",
")",
"Update",
"(",
"id",
"int",
",",
"maintenance",
"Maintenance",
")",
"(",
"*",
"PingdomResponse",
",",
"error",
")",
"{",
"if",
"err",
":=",
"maintenance",
".",
"Valid",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"req",
",",
"err",
":=",
"cs",
".",
"client",
".",
"NewRequest",
"(",
"\"",
"\"",
",",
"\"",
"\"",
"+",
"strconv",
".",
"Itoa",
"(",
"id",
")",
",",
"maintenance",
".",
"PutParams",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"m",
":=",
"&",
"PingdomResponse",
"{",
"}",
"\n",
"_",
",",
"err",
"=",
"cs",
".",
"client",
".",
"Do",
"(",
"req",
",",
"m",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"m",
",",
"err",
"\n",
"}"
] |
// Update is used to update an existing Maintenance. Only the 'Description',
// and 'To' fields can be updated.
|
[
"Update",
"is",
"used",
"to",
"update",
"an",
"existing",
"Maintenance",
".",
"Only",
"the",
"Description",
"and",
"To",
"fields",
"can",
"be",
"updated",
"."
] |
017c8281f6d1a98515f8575e5152e02f545a5553
|
https://github.com/russellcardullo/go-pingdom/blob/017c8281f6d1a98515f8575e5152e02f545a5553/pingdom/maintenance.go#L98-L114
|
17,815 |
russellcardullo/go-pingdom
|
pingdom/maintenance.go
|
MultiDelete
|
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
|
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
}
|
[
"func",
"(",
"cs",
"*",
"MaintenanceService",
")",
"MultiDelete",
"(",
"maintenance",
"MaintenanceDelete",
")",
"(",
"*",
"PingdomResponse",
",",
"error",
")",
"{",
"if",
"err",
":=",
"maintenance",
".",
"ValidDelete",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"req",
",",
"err",
":=",
"cs",
".",
"client",
".",
"NewRequest",
"(",
"\"",
"\"",
",",
"\"",
"\"",
",",
"maintenance",
".",
"DeleteParams",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"m",
":=",
"&",
"PingdomResponse",
"{",
"}",
"\n",
"_",
",",
"err",
"=",
"cs",
".",
"client",
".",
"Do",
"(",
"req",
",",
"m",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"m",
",",
"err",
"\n",
"}"
] |
// MultiDelete will delete the Maintenance for the given ID.
|
[
"MultiDelete",
"will",
"delete",
"the",
"Maintenance",
"for",
"the",
"given",
"ID",
"."
] |
017c8281f6d1a98515f8575e5152e02f545a5553
|
https://github.com/russellcardullo/go-pingdom/blob/017c8281f6d1a98515f8575e5152e02f545a5553/pingdom/maintenance.go#L117-L133
|
17,816 |
russellcardullo/go-pingdom
|
pingdom/user.go
|
List
|
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
|
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
}
|
[
"func",
"(",
"cs",
"*",
"UserService",
")",
"List",
"(",
")",
"(",
"[",
"]",
"UsersResponse",
",",
"error",
")",
"{",
"req",
",",
"err",
":=",
"cs",
".",
"client",
".",
"NewRequest",
"(",
"\"",
"\"",
",",
"\"",
"\"",
",",
"nil",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"resp",
",",
"err",
":=",
"cs",
".",
"client",
".",
"client",
".",
"Do",
"(",
"req",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"defer",
"resp",
".",
"Body",
".",
"Close",
"(",
")",
"\n\n",
"if",
"err",
":=",
"validateResponse",
"(",
"resp",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"bodyBytes",
",",
"_",
":=",
"ioutil",
".",
"ReadAll",
"(",
"resp",
".",
"Body",
")",
"\n",
"bodyString",
":=",
"string",
"(",
"bodyBytes",
")",
"\n\n",
"u",
":=",
"&",
"listUsersJSONResponse",
"{",
"}",
"\n",
"err",
"=",
"json",
".",
"Unmarshal",
"(",
"[",
"]",
"byte",
"(",
"bodyString",
")",
",",
"&",
"u",
")",
"\n\n",
"return",
"u",
".",
"Users",
",",
"err",
"\n",
"}"
] |
// List returns a list of all users and their contact details.
|
[
"List",
"returns",
"a",
"list",
"of",
"all",
"users",
"and",
"their",
"contact",
"details",
"."
] |
017c8281f6d1a98515f8575e5152e02f545a5553
|
https://github.com/russellcardullo/go-pingdom/blob/017c8281f6d1a98515f8575e5152e02f545a5553/pingdom/user.go#L23-L47
|
17,817 |
russellcardullo/go-pingdom
|
pingdom/user.go
|
Read
|
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
|
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")
}
|
[
"func",
"(",
"cs",
"*",
"UserService",
")",
"Read",
"(",
"userID",
"int",
")",
"(",
"*",
"UsersResponse",
",",
"error",
")",
"{",
"users",
",",
"err",
":=",
"cs",
".",
"List",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"for",
"i",
":=",
"range",
"users",
"{",
"if",
"users",
"[",
"i",
"]",
".",
"Id",
"==",
"userID",
"{",
"return",
"&",
"users",
"[",
"i",
"]",
",",
"nil",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
"+",
"strconv",
".",
"Itoa",
"(",
"userID",
")",
"+",
"\"",
"\"",
")",
"\n",
"}"
] |
// Read return a user object from Pingdom.
|
[
"Read",
"return",
"a",
"user",
"object",
"from",
"Pingdom",
"."
] |
017c8281f6d1a98515f8575e5152e02f545a5553
|
https://github.com/russellcardullo/go-pingdom/blob/017c8281f6d1a98515f8575e5152e02f545a5553/pingdom/user.go#L50-L63
|
17,818 |
russellcardullo/go-pingdom
|
pingdom/user.go
|
Create
|
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
|
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
}
|
[
"func",
"(",
"cs",
"*",
"UserService",
")",
"Create",
"(",
"user",
"UserApi",
")",
"(",
"*",
"UsersResponse",
",",
"error",
")",
"{",
"if",
"err",
":=",
"user",
".",
"ValidUser",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"req",
",",
"err",
":=",
"cs",
".",
"client",
".",
"NewRequest",
"(",
"\"",
"\"",
",",
"\"",
"\"",
",",
"user",
".",
"PostParams",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"m",
":=",
"&",
"createUserJSONResponse",
"{",
"}",
"\n",
"_",
",",
"err",
"=",
"cs",
".",
"client",
".",
"Do",
"(",
"req",
",",
"m",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"m",
".",
"User",
",",
"err",
"\n",
"}"
] |
// Create adds a new user.
|
[
"Create",
"adds",
"a",
"new",
"user",
"."
] |
017c8281f6d1a98515f8575e5152e02f545a5553
|
https://github.com/russellcardullo/go-pingdom/blob/017c8281f6d1a98515f8575e5152e02f545a5553/pingdom/user.go#L66-L82
|
17,819 |
russellcardullo/go-pingdom
|
pingdom/user.go
|
CreateContact
|
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
|
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
}
|
[
"func",
"(",
"cs",
"*",
"UserService",
")",
"CreateContact",
"(",
"userID",
"int",
",",
"contact",
"Contact",
")",
"(",
"*",
"CreateUserContactResponse",
",",
"error",
")",
"{",
"if",
"err",
":=",
"contact",
".",
"ValidContact",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"req",
",",
"err",
":=",
"cs",
".",
"client",
".",
"NewRequest",
"(",
"\"",
"\"",
",",
"\"",
"\"",
"+",
"strconv",
".",
"Itoa",
"(",
"userID",
")",
",",
"contact",
".",
"PostContactParams",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"m",
":=",
"&",
"createUserContactJSONResponse",
"{",
"}",
"\n",
"_",
",",
"err",
"=",
"cs",
".",
"client",
".",
"Do",
"(",
"req",
",",
"m",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"m",
".",
"Contact",
",",
"err",
"\n",
"}"
] |
// CreateContact adds a contact target to an existing user.
|
[
"CreateContact",
"adds",
"a",
"contact",
"target",
"to",
"an",
"existing",
"user",
"."
] |
017c8281f6d1a98515f8575e5152e02f545a5553
|
https://github.com/russellcardullo/go-pingdom/blob/017c8281f6d1a98515f8575e5152e02f545a5553/pingdom/user.go#L85-L101
|
17,820 |
russellcardullo/go-pingdom
|
pingdom/user.go
|
Update
|
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
|
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
}
|
[
"func",
"(",
"cs",
"*",
"UserService",
")",
"Update",
"(",
"id",
"int",
",",
"user",
"UserApi",
")",
"(",
"*",
"PingdomResponse",
",",
"error",
")",
"{",
"if",
"err",
":=",
"user",
".",
"ValidUser",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"req",
",",
"err",
":=",
"cs",
".",
"client",
".",
"NewRequest",
"(",
"\"",
"\"",
",",
"\"",
"\"",
"+",
"strconv",
".",
"Itoa",
"(",
"id",
")",
",",
"user",
".",
"PutParams",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"m",
":=",
"&",
"PingdomResponse",
"{",
"}",
"\n",
"_",
",",
"err",
"=",
"cs",
".",
"client",
".",
"Do",
"(",
"req",
",",
"m",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"m",
",",
"err",
"\n",
"}"
] |
// Update a user's core properties not contact targets.
|
[
"Update",
"a",
"user",
"s",
"core",
"properties",
"not",
"contact",
"targets",
"."
] |
017c8281f6d1a98515f8575e5152e02f545a5553
|
https://github.com/russellcardullo/go-pingdom/blob/017c8281f6d1a98515f8575e5152e02f545a5553/pingdom/user.go#L104-L120
|
17,821 |
russellcardullo/go-pingdom
|
pingdom/user.go
|
UpdateContact
|
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
|
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
}
|
[
"func",
"(",
"cs",
"*",
"UserService",
")",
"UpdateContact",
"(",
"userID",
"int",
",",
"contactID",
"int",
",",
"contact",
"Contact",
")",
"(",
"*",
"PingdomResponse",
",",
"error",
")",
"{",
"if",
"err",
":=",
"contact",
".",
"ValidContact",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"req",
",",
"err",
":=",
"cs",
".",
"client",
".",
"NewRequest",
"(",
"\"",
"\"",
",",
"\"",
"\"",
"+",
"strconv",
".",
"Itoa",
"(",
"userID",
")",
"+",
"\"",
"\"",
"+",
"strconv",
".",
"Itoa",
"(",
"contactID",
")",
",",
"contact",
".",
"PutContactParams",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"m",
":=",
"&",
"PingdomResponse",
"{",
"}",
"\n",
"_",
",",
"err",
"=",
"cs",
".",
"client",
".",
"Do",
"(",
"req",
",",
"m",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"m",
",",
"err",
"\n",
"}"
] |
// UpdateContact updates a contact by id, will change an email to sms or sms to email
// if you provide an id for the other.
|
[
"UpdateContact",
"updates",
"a",
"contact",
"by",
"id",
"will",
"change",
"an",
"email",
"to",
"sms",
"or",
"sms",
"to",
"email",
"if",
"you",
"provide",
"an",
"id",
"for",
"the",
"other",
"."
] |
017c8281f6d1a98515f8575e5152e02f545a5553
|
https://github.com/russellcardullo/go-pingdom/blob/017c8281f6d1a98515f8575e5152e02f545a5553/pingdom/user.go#L124-L140
|
17,822 |
russellcardullo/go-pingdom
|
pingdom/user.go
|
DeleteContact
|
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
|
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
}
|
[
"func",
"(",
"cs",
"*",
"UserService",
")",
"DeleteContact",
"(",
"userID",
"int",
",",
"contactID",
"int",
")",
"(",
"*",
"PingdomResponse",
",",
"error",
")",
"{",
"req",
",",
"err",
":=",
"cs",
".",
"client",
".",
"NewRequest",
"(",
"\"",
"\"",
",",
"\"",
"\"",
"+",
"strconv",
".",
"Itoa",
"(",
"userID",
")",
"+",
"\"",
"\"",
"+",
"strconv",
".",
"Itoa",
"(",
"contactID",
")",
",",
"nil",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"m",
":=",
"&",
"PingdomResponse",
"{",
"}",
"\n",
"_",
",",
"err",
"=",
"cs",
".",
"client",
".",
"Do",
"(",
"req",
",",
"m",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"m",
",",
"err",
"\n",
"}"
] |
// DeleteContact deletes a contact target from a user, either an email or sms property of a user.
|
[
"DeleteContact",
"deletes",
"a",
"contact",
"target",
"from",
"a",
"user",
"either",
"an",
"email",
"or",
"sms",
"property",
"of",
"a",
"user",
"."
] |
017c8281f6d1a98515f8575e5152e02f545a5553
|
https://github.com/russellcardullo/go-pingdom/blob/017c8281f6d1a98515f8575e5152e02f545a5553/pingdom/user.go#L158-L170
|
17,823 |
russellcardullo/go-pingdom
|
pingdom/team.go
|
List
|
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
|
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
}
|
[
"func",
"(",
"cs",
"*",
"TeamService",
")",
"List",
"(",
")",
"(",
"[",
"]",
"TeamResponse",
",",
"error",
")",
"{",
"req",
",",
"err",
":=",
"cs",
".",
"client",
".",
"NewRequest",
"(",
"\"",
"\"",
",",
"\"",
"\"",
",",
"nil",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"resp",
",",
"err",
":=",
"cs",
".",
"client",
".",
"client",
".",
"Do",
"(",
"req",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"defer",
"resp",
".",
"Body",
".",
"Close",
"(",
")",
"\n\n",
"if",
"err",
":=",
"validateResponse",
"(",
"resp",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"bodyBytes",
",",
"_",
":=",
"ioutil",
".",
"ReadAll",
"(",
"resp",
".",
"Body",
")",
"\n",
"bodyString",
":=",
"string",
"(",
"bodyBytes",
")",
"\n\n",
"t",
":=",
"&",
"listTeamsJSONResponse",
"{",
"}",
"\n",
"err",
"=",
"json",
".",
"Unmarshal",
"(",
"[",
"]",
"byte",
"(",
"bodyString",
")",
",",
"&",
"t",
")",
"\n\n",
"return",
"t",
".",
"Teams",
",",
"err",
"\n",
"}"
] |
// List return a list of teams from Pingdom.
|
[
"List",
"return",
"a",
"list",
"of",
"teams",
"from",
"Pingdom",
"."
] |
017c8281f6d1a98515f8575e5152e02f545a5553
|
https://github.com/russellcardullo/go-pingdom/blob/017c8281f6d1a98515f8575e5152e02f545a5553/pingdom/team.go#L22-L45
|
17,824 |
russellcardullo/go-pingdom
|
pingdom/team.go
|
Read
|
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
|
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
}
|
[
"func",
"(",
"cs",
"*",
"TeamService",
")",
"Read",
"(",
"id",
"int",
")",
"(",
"*",
"TeamResponse",
",",
"error",
")",
"{",
"req",
",",
"err",
":=",
"cs",
".",
"client",
".",
"NewRequest",
"(",
"\"",
"\"",
",",
"\"",
"\"",
"+",
"strconv",
".",
"Itoa",
"(",
"id",
")",
",",
"nil",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"t",
":=",
"&",
"teamDetailsJSONResponse",
"{",
"}",
"\n",
"_",
",",
"err",
"=",
"cs",
".",
"client",
".",
"Do",
"(",
"req",
",",
"t",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"t",
".",
"Team",
",",
"err",
"\n",
"}"
] |
// Read return a team object from Pingdom.
|
[
"Read",
"return",
"a",
"team",
"object",
"from",
"Pingdom",
"."
] |
017c8281f6d1a98515f8575e5152e02f545a5553
|
https://github.com/russellcardullo/go-pingdom/blob/017c8281f6d1a98515f8575e5152e02f545a5553/pingdom/team.go#L48-L61
|
17,825 |
russellcardullo/go-pingdom
|
pingdom/team.go
|
Create
|
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
|
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
}
|
[
"func",
"(",
"cs",
"*",
"TeamService",
")",
"Create",
"(",
"team",
"Team",
")",
"(",
"*",
"TeamResponse",
",",
"error",
")",
"{",
"if",
"err",
":=",
"team",
".",
"Valid",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"req",
",",
"err",
":=",
"cs",
".",
"client",
".",
"NewRequest",
"(",
"\"",
"\"",
",",
"\"",
"\"",
",",
"team",
".",
"PostParams",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"t",
":=",
"&",
"TeamResponse",
"{",
"}",
"\n",
"_",
",",
"err",
"=",
"cs",
".",
"client",
".",
"Do",
"(",
"req",
",",
"t",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"t",
",",
"err",
"\n",
"}"
] |
// Create is used to create a new team.
|
[
"Create",
"is",
"used",
"to",
"create",
"a",
"new",
"team",
"."
] |
017c8281f6d1a98515f8575e5152e02f545a5553
|
https://github.com/russellcardullo/go-pingdom/blob/017c8281f6d1a98515f8575e5152e02f545a5553/pingdom/team.go#L64-L80
|
17,826 |
russellcardullo/go-pingdom
|
pingdom/team.go
|
Update
|
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
|
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
}
|
[
"func",
"(",
"cs",
"*",
"TeamService",
")",
"Update",
"(",
"id",
"int",
",",
"team",
"Team",
")",
"(",
"*",
"TeamResponse",
",",
"error",
")",
"{",
"req",
",",
"err",
":=",
"cs",
".",
"client",
".",
"NewRequest",
"(",
"\"",
"\"",
",",
"\"",
"\"",
"+",
"strconv",
".",
"Itoa",
"(",
"id",
")",
",",
"team",
".",
"PutParams",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"t",
":=",
"&",
"TeamResponse",
"{",
"}",
"\n",
"_",
",",
"err",
"=",
"cs",
".",
"client",
".",
"Do",
"(",
"req",
",",
"t",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"t",
",",
"err",
"\n",
"}"
] |
// Update is used to update existing team.
|
[
"Update",
"is",
"used",
"to",
"update",
"existing",
"team",
"."
] |
017c8281f6d1a98515f8575e5152e02f545a5553
|
https://github.com/russellcardullo/go-pingdom/blob/017c8281f6d1a98515f8575e5152e02f545a5553/pingdom/team.go#L83-L95
|
17,827 |
russellcardullo/go-pingdom
|
pingdom/team.go
|
Delete
|
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
|
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
}
|
[
"func",
"(",
"cs",
"*",
"TeamService",
")",
"Delete",
"(",
"id",
"int",
")",
"(",
"*",
"TeamDeleteResponse",
",",
"error",
")",
"{",
"req",
",",
"err",
":=",
"cs",
".",
"client",
".",
"NewRequest",
"(",
"\"",
"\"",
",",
"\"",
"\"",
"+",
"strconv",
".",
"Itoa",
"(",
"id",
")",
",",
"nil",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"t",
":=",
"&",
"TeamDeleteResponse",
"{",
"}",
"\n",
"_",
",",
"err",
"=",
"cs",
".",
"client",
".",
"Do",
"(",
"req",
",",
"t",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"t",
",",
"err",
"\n",
"}"
] |
// Delete will delete the Team for the given ID.
|
[
"Delete",
"will",
"delete",
"the",
"Team",
"for",
"the",
"given",
"ID",
"."
] |
017c8281f6d1a98515f8575e5152e02f545a5553
|
https://github.com/russellcardullo/go-pingdom/blob/017c8281f6d1a98515f8575e5152e02f545a5553/pingdom/team.go#L98-L110
|
17,828 |
russellcardullo/go-pingdom
|
pingdom/maintenance_type.go
|
PutParams
|
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
|
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
}
|
[
"func",
"(",
"ck",
"*",
"MaintenanceWindow",
")",
"PutParams",
"(",
")",
"map",
"[",
"string",
"]",
"string",
"{",
"m",
":=",
"map",
"[",
"string",
"]",
"string",
"{",
"\"",
"\"",
":",
"ck",
".",
"Description",
",",
"\"",
"\"",
":",
"strconv",
".",
"FormatInt",
"(",
"ck",
".",
"From",
",",
"10",
")",
",",
"\"",
"\"",
":",
"strconv",
".",
"FormatInt",
"(",
"ck",
".",
"To",
",",
"10",
")",
",",
"}",
"\n\n",
"// Ignore if not defined",
"if",
"ck",
".",
"RecurrenceType",
"!=",
"\"",
"\"",
"{",
"m",
"[",
"\"",
"\"",
"]",
"=",
"ck",
".",
"RecurrenceType",
"\n",
"}",
"\n\n",
"if",
"ck",
".",
"UptimeIDs",
"!=",
"\"",
"\"",
"{",
"m",
"[",
"\"",
"\"",
"]",
"=",
"ck",
".",
"UptimeIDs",
"\n",
"}",
"\n\n",
"if",
"ck",
".",
"TmsIDs",
"!=",
"\"",
"\"",
"{",
"m",
"[",
"\"",
"\"",
"]",
"=",
"ck",
".",
"TmsIDs",
"\n",
"}",
"\n\n",
"if",
"ck",
".",
"RepeatEvery",
"!=",
"0",
"{",
"m",
"[",
"\"",
"\"",
"]",
"=",
"strconv",
".",
"Itoa",
"(",
"ck",
".",
"RepeatEvery",
")",
"\n",
"}",
"\n\n",
"if",
"ck",
".",
"EffectiveTo",
"!=",
"0",
"{",
"m",
"[",
"\"",
"\"",
"]",
"=",
"strconv",
".",
"Itoa",
"(",
"ck",
".",
"EffectiveTo",
")",
"\n",
"}",
"\n\n",
"return",
"m",
"\n",
"}"
] |
// PutParams returns a map of parameters for an MaintenanceWindow that can be sent along.
|
[
"PutParams",
"returns",
"a",
"map",
"of",
"parameters",
"for",
"an",
"MaintenanceWindow",
"that",
"can",
"be",
"sent",
"along",
"."
] |
017c8281f6d1a98515f8575e5152e02f545a5553
|
https://github.com/russellcardullo/go-pingdom/blob/017c8281f6d1a98515f8575e5152e02f545a5553/pingdom/maintenance_type.go#L26-L55
|
17,829 |
russellcardullo/go-pingdom
|
pingdom/maintenance_type.go
|
Valid
|
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
|
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
}
|
[
"func",
"(",
"ck",
"*",
"MaintenanceWindow",
")",
"Valid",
"(",
")",
"error",
"{",
"if",
"ck",
".",
"Description",
"==",
"\"",
"\"",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"if",
"ck",
".",
"From",
"==",
"0",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"if",
"ck",
".",
"To",
"==",
"0",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] |
// Valid determines whether the MaintenanceWindow contains valid fields. This can be
// used to guard against sending illegal values to the Pingdom API.
|
[
"Valid",
"determines",
"whether",
"the",
"MaintenanceWindow",
"contains",
"valid",
"fields",
".",
"This",
"can",
"be",
"used",
"to",
"guard",
"against",
"sending",
"illegal",
"values",
"to",
"the",
"Pingdom",
"API",
"."
] |
017c8281f6d1a98515f8575e5152e02f545a5553
|
https://github.com/russellcardullo/go-pingdom/blob/017c8281f6d1a98515f8575e5152e02f545a5553/pingdom/maintenance_type.go#L74-L88
|
17,830 |
russellcardullo/go-pingdom
|
pingdom/maintenance_type.go
|
DeleteParams
|
func (ck *MaintenanceWindowDelete) DeleteParams() map[string]string {
m := map[string]string{
"maintenanceids": ck.MaintenanceIDs,
}
return m
}
|
go
|
func (ck *MaintenanceWindowDelete) DeleteParams() map[string]string {
m := map[string]string{
"maintenanceids": ck.MaintenanceIDs,
}
return m
}
|
[
"func",
"(",
"ck",
"*",
"MaintenanceWindowDelete",
")",
"DeleteParams",
"(",
")",
"map",
"[",
"string",
"]",
"string",
"{",
"m",
":=",
"map",
"[",
"string",
"]",
"string",
"{",
"\"",
"\"",
":",
"ck",
".",
"MaintenanceIDs",
",",
"}",
"\n\n",
"return",
"m",
"\n",
"}"
] |
// DeleteParams returns a map of parameters for an MaintenanceWindow that can be sent along.
|
[
"DeleteParams",
"returns",
"a",
"map",
"of",
"parameters",
"for",
"an",
"MaintenanceWindow",
"that",
"can",
"be",
"sent",
"along",
"."
] |
017c8281f6d1a98515f8575e5152e02f545a5553
|
https://github.com/russellcardullo/go-pingdom/blob/017c8281f6d1a98515f8575e5152e02f545a5553/pingdom/maintenance_type.go#L91-L97
|
17,831 |
russellcardullo/go-pingdom
|
pingdom/check.go
|
List
|
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
|
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
}
|
[
"func",
"(",
"cs",
"*",
"CheckService",
")",
"List",
"(",
"params",
"...",
"map",
"[",
"string",
"]",
"string",
")",
"(",
"[",
"]",
"CheckResponse",
",",
"error",
")",
"{",
"param",
":=",
"map",
"[",
"string",
"]",
"string",
"{",
"}",
"\n",
"if",
"len",
"(",
"params",
")",
"==",
"1",
"{",
"param",
"=",
"params",
"[",
"0",
"]",
"\n",
"}",
"\n",
"req",
",",
"err",
":=",
"cs",
".",
"client",
".",
"NewRequest",
"(",
"\"",
"\"",
",",
"\"",
"\"",
",",
"param",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"resp",
",",
"err",
":=",
"cs",
".",
"client",
".",
"client",
".",
"Do",
"(",
"req",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"defer",
"resp",
".",
"Body",
".",
"Close",
"(",
")",
"\n\n",
"if",
"err",
":=",
"validateResponse",
"(",
"resp",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"bodyBytes",
",",
"_",
":=",
"ioutil",
".",
"ReadAll",
"(",
"resp",
".",
"Body",
")",
"\n",
"bodyString",
":=",
"string",
"(",
"bodyBytes",
")",
"\n",
"m",
":=",
"&",
"listChecksJSONResponse",
"{",
"}",
"\n",
"err",
"=",
"json",
".",
"Unmarshal",
"(",
"[",
"]",
"byte",
"(",
"bodyString",
")",
",",
"&",
"m",
")",
"\n\n",
"return",
"m",
".",
"Checks",
",",
"err",
"\n",
"}"
] |
// List returns a list of checks from Pingdom.
// This returns type CheckResponse rather than Check since the
// Pingdom API does not return a complete representation of a check.
|
[
"List",
"returns",
"a",
"list",
"of",
"checks",
"from",
"Pingdom",
".",
"This",
"returns",
"type",
"CheckResponse",
"rather",
"than",
"Check",
"since",
"the",
"Pingdom",
"API",
"does",
"not",
"return",
"a",
"complete",
"representation",
"of",
"a",
"check",
"."
] |
017c8281f6d1a98515f8575e5152e02f545a5553
|
https://github.com/russellcardullo/go-pingdom/blob/017c8281f6d1a98515f8575e5152e02f545a5553/pingdom/check.go#L25-L51
|
17,832 |
russellcardullo/go-pingdom
|
pingdom/check.go
|
Create
|
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
|
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
}
|
[
"func",
"(",
"cs",
"*",
"CheckService",
")",
"Create",
"(",
"check",
"Check",
")",
"(",
"*",
"CheckResponse",
",",
"error",
")",
"{",
"if",
"err",
":=",
"check",
".",
"Valid",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"req",
",",
"err",
":=",
"cs",
".",
"client",
".",
"NewRequest",
"(",
"\"",
"\"",
",",
"\"",
"\"",
",",
"check",
".",
"PostParams",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"m",
":=",
"&",
"checkDetailsJSONResponse",
"{",
"}",
"\n",
"_",
",",
"err",
"=",
"cs",
".",
"client",
".",
"Do",
"(",
"req",
",",
"m",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"m",
".",
"Check",
",",
"err",
"\n",
"}"
] |
// Create a new check. This function will validate the given check param
// to ensure that it contains correct values before submitting the request
// Returns a CheckResponse object representing the response from Pingdom.
// Note that Pingdom does not return a full check object so in the returned
// object you should only use the ID field.
|
[
"Create",
"a",
"new",
"check",
".",
"This",
"function",
"will",
"validate",
"the",
"given",
"check",
"param",
"to",
"ensure",
"that",
"it",
"contains",
"correct",
"values",
"before",
"submitting",
"the",
"request",
"Returns",
"a",
"CheckResponse",
"object",
"representing",
"the",
"response",
"from",
"Pingdom",
".",
"Note",
"that",
"Pingdom",
"does",
"not",
"return",
"a",
"full",
"check",
"object",
"so",
"in",
"the",
"returned",
"object",
"you",
"should",
"only",
"use",
"the",
"ID",
"field",
"."
] |
017c8281f6d1a98515f8575e5152e02f545a5553
|
https://github.com/russellcardullo/go-pingdom/blob/017c8281f6d1a98515f8575e5152e02f545a5553/pingdom/check.go#L58-L74
|
17,833 |
russellcardullo/go-pingdom
|
pingdom/check.go
|
Read
|
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
|
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
}
|
[
"func",
"(",
"cs",
"*",
"CheckService",
")",
"Read",
"(",
"id",
"int",
")",
"(",
"*",
"CheckResponse",
",",
"error",
")",
"{",
"req",
",",
"err",
":=",
"cs",
".",
"client",
".",
"NewRequest",
"(",
"\"",
"\"",
",",
"\"",
"\"",
"+",
"strconv",
".",
"Itoa",
"(",
"id",
")",
"+",
"\"",
"\"",
",",
"nil",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"m",
":=",
"&",
"checkDetailsJSONResponse",
"{",
"}",
"\n",
"_",
",",
"err",
"=",
"cs",
".",
"client",
".",
"Do",
"(",
"req",
",",
"m",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"m",
".",
"Check",
".",
"TeamIds",
"=",
"make",
"(",
"[",
"]",
"int",
",",
"len",
"(",
"m",
".",
"Check",
".",
"Teams",
")",
")",
"\n",
"for",
"i",
":=",
"range",
"m",
".",
"Check",
".",
"Teams",
"{",
"m",
".",
"Check",
".",
"TeamIds",
"[",
"i",
"]",
"=",
"m",
".",
"Check",
".",
"Teams",
"[",
"i",
"]",
".",
"ID",
"\n",
"}",
"\n\n",
"return",
"m",
".",
"Check",
",",
"err",
"\n",
"}"
] |
// ReadCheck returns detailed information about a pingdom check given its ID.
// This returns type CheckResponse rather than Check since the
// pingdom API does not return a complete representation of a check.
|
[
"ReadCheck",
"returns",
"detailed",
"information",
"about",
"a",
"pingdom",
"check",
"given",
"its",
"ID",
".",
"This",
"returns",
"type",
"CheckResponse",
"rather",
"than",
"Check",
"since",
"the",
"pingdom",
"API",
"does",
"not",
"return",
"a",
"complete",
"representation",
"of",
"a",
"check",
"."
] |
017c8281f6d1a98515f8575e5152e02f545a5553
|
https://github.com/russellcardullo/go-pingdom/blob/017c8281f6d1a98515f8575e5152e02f545a5553/pingdom/check.go#L79-L96
|
17,834 |
russellcardullo/go-pingdom
|
pingdom/check.go
|
Update
|
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
|
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
}
|
[
"func",
"(",
"cs",
"*",
"CheckService",
")",
"Update",
"(",
"id",
"int",
",",
"check",
"Check",
")",
"(",
"*",
"PingdomResponse",
",",
"error",
")",
"{",
"if",
"err",
":=",
"check",
".",
"Valid",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"req",
",",
"err",
":=",
"cs",
".",
"client",
".",
"NewRequest",
"(",
"\"",
"\"",
",",
"\"",
"\"",
"+",
"strconv",
".",
"Itoa",
"(",
"id",
")",
",",
"check",
".",
"PutParams",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"m",
":=",
"&",
"PingdomResponse",
"{",
"}",
"\n",
"_",
",",
"err",
"=",
"cs",
".",
"client",
".",
"Do",
"(",
"req",
",",
"m",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"m",
",",
"err",
"\n",
"}"
] |
// Update will update the check represented by the given ID with the values
// in the given check. You should submit the complete list of values in
// the given check parameter, not just those that have changed.
|
[
"Update",
"will",
"update",
"the",
"check",
"represented",
"by",
"the",
"given",
"ID",
"with",
"the",
"values",
"in",
"the",
"given",
"check",
".",
"You",
"should",
"submit",
"the",
"complete",
"list",
"of",
"values",
"in",
"the",
"given",
"check",
"parameter",
"not",
"just",
"those",
"that",
"have",
"changed",
"."
] |
017c8281f6d1a98515f8575e5152e02f545a5553
|
https://github.com/russellcardullo/go-pingdom/blob/017c8281f6d1a98515f8575e5152e02f545a5553/pingdom/check.go#L101-L117
|
17,835 |
russellcardullo/go-pingdom
|
pingdom/check.go
|
Delete
|
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
|
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
}
|
[
"func",
"(",
"cs",
"*",
"CheckService",
")",
"Delete",
"(",
"id",
"int",
")",
"(",
"*",
"PingdomResponse",
",",
"error",
")",
"{",
"req",
",",
"err",
":=",
"cs",
".",
"client",
".",
"NewRequest",
"(",
"\"",
"\"",
",",
"\"",
"\"",
"+",
"strconv",
".",
"Itoa",
"(",
"id",
")",
",",
"nil",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"m",
":=",
"&",
"PingdomResponse",
"{",
"}",
"\n",
"_",
",",
"err",
"=",
"cs",
".",
"client",
".",
"Do",
"(",
"req",
",",
"m",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"m",
",",
"err",
"\n",
"}"
] |
// Delete will delete the check for the given ID.
|
[
"Delete",
"will",
"delete",
"the",
"check",
"for",
"the",
"given",
"ID",
"."
] |
017c8281f6d1a98515f8575e5152e02f545a5553
|
https://github.com/russellcardullo/go-pingdom/blob/017c8281f6d1a98515f8575e5152e02f545a5553/pingdom/check.go#L120-L132
|
17,836 |
russellcardullo/go-pingdom
|
pingdom/check.go
|
SummaryPerformance
|
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
|
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
}
|
[
"func",
"(",
"cs",
"*",
"CheckService",
")",
"SummaryPerformance",
"(",
"request",
"SummaryPerformanceRequest",
")",
"(",
"*",
"SummaryPerformanceResponse",
",",
"error",
")",
"{",
"if",
"err",
":=",
"request",
".",
"Valid",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"req",
",",
"err",
":=",
"cs",
".",
"client",
".",
"NewRequest",
"(",
"\"",
"\"",
",",
"\"",
"\"",
"+",
"strconv",
".",
"Itoa",
"(",
"request",
".",
"Id",
")",
",",
"request",
".",
"GetParams",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"m",
":=",
"&",
"SummaryPerformanceResponse",
"{",
"}",
"\n",
"_",
",",
"err",
"=",
"cs",
".",
"client",
".",
"Do",
"(",
"req",
",",
"m",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"m",
",",
"nil",
"\n",
"}"
] |
// SummaryPerformance returns a performance summary from Pingdom.
|
[
"SummaryPerformance",
"returns",
"a",
"performance",
"summary",
"from",
"Pingdom",
"."
] |
017c8281f6d1a98515f8575e5152e02f545a5553
|
https://github.com/russellcardullo/go-pingdom/blob/017c8281f6d1a98515f8575e5152e02f545a5553/pingdom/check.go#L135-L151
|
17,837 |
russellcardullo/go-pingdom
|
pingdom/pingdom.go
|
NewClientWithConfig
|
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
|
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
}
|
[
"func",
"NewClientWithConfig",
"(",
"config",
"ClientConfig",
")",
"(",
"*",
"Client",
",",
"error",
")",
"{",
"var",
"baseURL",
"*",
"url",
".",
"URL",
"\n",
"var",
"err",
"error",
"\n",
"if",
"config",
".",
"BaseURL",
"!=",
"\"",
"\"",
"{",
"baseURL",
",",
"err",
"=",
"url",
".",
"Parse",
"(",
"config",
".",
"BaseURL",
")",
"\n",
"}",
"else",
"{",
"baseURL",
",",
"err",
"=",
"url",
".",
"Parse",
"(",
"defaultBaseURL",
")",
"\n",
"}",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"c",
":=",
"&",
"Client",
"{",
"User",
":",
"config",
".",
"User",
",",
"Password",
":",
"config",
".",
"Password",
",",
"APIKey",
":",
"config",
".",
"APIKey",
",",
"AccountEmail",
":",
"config",
".",
"AccountEmail",
",",
"BaseURL",
":",
"baseURL",
",",
"}",
"\n\n",
"if",
"config",
".",
"HTTPClient",
"!=",
"nil",
"{",
"c",
".",
"client",
"=",
"config",
".",
"HTTPClient",
"\n",
"}",
"else",
"{",
"c",
".",
"client",
"=",
"http",
".",
"DefaultClient",
"\n",
"}",
"\n\n",
"c",
".",
"Checks",
"=",
"&",
"CheckService",
"{",
"client",
":",
"c",
"}",
"\n",
"c",
".",
"Maintenances",
"=",
"&",
"MaintenanceService",
"{",
"client",
":",
"c",
"}",
"\n",
"c",
".",
"Probes",
"=",
"&",
"ProbeService",
"{",
"client",
":",
"c",
"}",
"\n",
"c",
".",
"Teams",
"=",
"&",
"TeamService",
"{",
"client",
":",
"c",
"}",
"\n",
"c",
".",
"PublicReport",
"=",
"&",
"PublicReportService",
"{",
"client",
":",
"c",
"}",
"\n",
"c",
".",
"Users",
"=",
"&",
"UserService",
"{",
"client",
":",
"c",
"}",
"\n",
"return",
"c",
",",
"nil",
"\n",
"}"
] |
// NewClientWithConfig returns a Pingdom client.
|
[
"NewClientWithConfig",
"returns",
"a",
"Pingdom",
"client",
"."
] |
017c8281f6d1a98515f8575e5152e02f545a5553
|
https://github.com/russellcardullo/go-pingdom/blob/017c8281f6d1a98515f8575e5152e02f545a5553/pingdom/pingdom.go#L44-L77
|
17,838 |
russellcardullo/go-pingdom
|
pingdom/pingdom.go
|
NewRequest
|
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
|
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
}
|
[
"func",
"(",
"pc",
"*",
"Client",
")",
"NewRequest",
"(",
"method",
"string",
",",
"rsc",
"string",
",",
"params",
"map",
"[",
"string",
"]",
"string",
")",
"(",
"*",
"http",
".",
"Request",
",",
"error",
")",
"{",
"baseURL",
",",
"err",
":=",
"url",
".",
"Parse",
"(",
"pc",
".",
"BaseURL",
".",
"String",
"(",
")",
"+",
"rsc",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"if",
"params",
"!=",
"nil",
"{",
"ps",
":=",
"url",
".",
"Values",
"{",
"}",
"\n",
"for",
"k",
",",
"v",
":=",
"range",
"params",
"{",
"ps",
".",
"Set",
"(",
"k",
",",
"v",
")",
"\n",
"}",
"\n",
"baseURL",
".",
"RawQuery",
"=",
"ps",
".",
"Encode",
"(",
")",
"\n",
"}",
"\n\n",
"req",
",",
"err",
":=",
"http",
".",
"NewRequest",
"(",
"method",
",",
"baseURL",
".",
"String",
"(",
")",
",",
"nil",
")",
"\n",
"req",
".",
"SetBasicAuth",
"(",
"pc",
".",
"User",
",",
"pc",
".",
"Password",
")",
"\n",
"req",
".",
"Header",
".",
"Add",
"(",
"\"",
"\"",
",",
"pc",
".",
"APIKey",
")",
"\n",
"if",
"pc",
".",
"AccountEmail",
"!=",
"\"",
"\"",
"{",
"req",
".",
"Header",
".",
"Add",
"(",
"\"",
"\"",
",",
"pc",
".",
"AccountEmail",
")",
"\n",
"}",
"\n",
"return",
"req",
",",
"err",
"\n",
"}"
] |
// NewRequest makes a new HTTP Request. The method param should be an HTTP method in
// all caps such as GET, POST, PUT, DELETE. The rsc param should correspond with
// a restful resource. Params can be passed in as a map of strings
// Usually users of the client can use one of the convenience methods such as
// ListChecks, etc but this method is provided to allow for making other
// API calls that might not be built in.
|
[
"NewRequest",
"makes",
"a",
"new",
"HTTP",
"Request",
".",
"The",
"method",
"param",
"should",
"be",
"an",
"HTTP",
"method",
"in",
"all",
"caps",
"such",
"as",
"GET",
"POST",
"PUT",
"DELETE",
".",
"The",
"rsc",
"param",
"should",
"correspond",
"with",
"a",
"restful",
"resource",
".",
"Params",
"can",
"be",
"passed",
"in",
"as",
"a",
"map",
"of",
"strings",
"Usually",
"users",
"of",
"the",
"client",
"can",
"use",
"one",
"of",
"the",
"convenience",
"methods",
"such",
"as",
"ListChecks",
"etc",
"but",
"this",
"method",
"is",
"provided",
"to",
"allow",
"for",
"making",
"other",
"API",
"calls",
"that",
"might",
"not",
"be",
"built",
"in",
"."
] |
017c8281f6d1a98515f8575e5152e02f545a5553
|
https://github.com/russellcardullo/go-pingdom/blob/017c8281f6d1a98515f8575e5152e02f545a5553/pingdom/pingdom.go#L110-L131
|
17,839 |
russellcardullo/go-pingdom
|
pingdom/pingdom.go
|
Do
|
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
|
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
}
|
[
"func",
"(",
"pc",
"*",
"Client",
")",
"Do",
"(",
"req",
"*",
"http",
".",
"Request",
",",
"v",
"interface",
"{",
"}",
")",
"(",
"*",
"http",
".",
"Response",
",",
"error",
")",
"{",
"resp",
",",
"err",
":=",
"pc",
".",
"client",
".",
"Do",
"(",
"req",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"defer",
"resp",
".",
"Body",
".",
"Close",
"(",
")",
"\n\n",
"if",
"err",
":=",
"validateResponse",
"(",
"resp",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"resp",
",",
"err",
"\n",
"}",
"\n\n",
"err",
"=",
"decodeResponse",
"(",
"resp",
",",
"v",
")",
"\n",
"return",
"resp",
",",
"err",
"\n\n",
"}"
] |
// Do makes an HTTP request and will unmarshal the JSON response in to the
// passed in interface. If the HTTP response is outside of the 2xx range the
// response will be returned along with the error.
|
[
"Do",
"makes",
"an",
"HTTP",
"request",
"and",
"will",
"unmarshal",
"the",
"JSON",
"response",
"in",
"to",
"the",
"passed",
"in",
"interface",
".",
"If",
"the",
"HTTP",
"response",
"is",
"outside",
"of",
"the",
"2xx",
"range",
"the",
"response",
"will",
"be",
"returned",
"along",
"with",
"the",
"error",
"."
] |
017c8281f6d1a98515f8575e5152e02f545a5553
|
https://github.com/russellcardullo/go-pingdom/blob/017c8281f6d1a98515f8575e5152e02f545a5553/pingdom/pingdom.go#L136-L150
|
17,840 |
russellcardullo/go-pingdom
|
pingdom/pingdom.go
|
validateResponse
|
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
|
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
}
|
[
"func",
"validateResponse",
"(",
"r",
"*",
"http",
".",
"Response",
")",
"error",
"{",
"if",
"c",
":=",
"r",
".",
"StatusCode",
";",
"200",
"<=",
"c",
"&&",
"c",
"<=",
"299",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"bodyBytes",
",",
"_",
":=",
"ioutil",
".",
"ReadAll",
"(",
"r",
".",
"Body",
")",
"\n",
"bodyString",
":=",
"string",
"(",
"bodyBytes",
")",
"\n",
"m",
":=",
"&",
"errorJSONResponse",
"{",
"}",
"\n",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"[",
"]",
"byte",
"(",
"bodyString",
")",
",",
"&",
"m",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"return",
"m",
".",
"Error",
"\n",
"}"
] |
// Takes an HTTP response and determines whether it was successful.
// Returns nil if the HTTP status code is within the 2xx range. Returns
// an error otherwise.
|
[
"Takes",
"an",
"HTTP",
"response",
"and",
"determines",
"whether",
"it",
"was",
"successful",
".",
"Returns",
"nil",
"if",
"the",
"HTTP",
"status",
"code",
"is",
"within",
"the",
"2xx",
"range",
".",
"Returns",
"an",
"error",
"otherwise",
"."
] |
017c8281f6d1a98515f8575e5152e02f545a5553
|
https://github.com/russellcardullo/go-pingdom/blob/017c8281f6d1a98515f8575e5152e02f545a5553/pingdom/pingdom.go#L166-L180
|
17,841 |
russellcardullo/go-pingdom
|
pingdom/check_types.go
|
PutParams
|
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
|
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
}
|
[
"func",
"(",
"ck",
"*",
"HttpCheck",
")",
"PutParams",
"(",
")",
"map",
"[",
"string",
"]",
"string",
"{",
"m",
":=",
"map",
"[",
"string",
"]",
"string",
"{",
"\"",
"\"",
":",
"ck",
".",
"Name",
",",
"\"",
"\"",
":",
"ck",
".",
"Hostname",
",",
"\"",
"\"",
":",
"strconv",
".",
"Itoa",
"(",
"ck",
".",
"Resolution",
")",
",",
"\"",
"\"",
":",
"strconv",
".",
"FormatBool",
"(",
"ck",
".",
"Paused",
")",
",",
"\"",
"\"",
":",
"strconv",
".",
"Itoa",
"(",
"ck",
".",
"NotifyAgainEvery",
")",
",",
"\"",
"\"",
":",
"strconv",
".",
"FormatBool",
"(",
"ck",
".",
"NotifyWhenBackup",
")",
",",
"\"",
"\"",
":",
"ck",
".",
"Url",
",",
"\"",
"\"",
":",
"strconv",
".",
"FormatBool",
"(",
"ck",
".",
"Encryption",
")",
",",
"\"",
"\"",
":",
"ck",
".",
"PostData",
",",
"\"",
"\"",
":",
"intListToCDString",
"(",
"ck",
".",
"IntegrationIds",
")",
",",
"\"",
"\"",
":",
"ck",
".",
"Tags",
",",
"\"",
"\"",
":",
"ck",
".",
"ProbeFilters",
",",
"\"",
"\"",
":",
"intListToCDString",
"(",
"ck",
".",
"UserIds",
")",
",",
"\"",
"\"",
":",
"intListToCDString",
"(",
"ck",
".",
"TeamIds",
")",
",",
"}",
"\n\n",
"// Ignore zero values",
"if",
"ck",
".",
"Port",
"!=",
"0",
"{",
"m",
"[",
"\"",
"\"",
"]",
"=",
"strconv",
".",
"Itoa",
"(",
"ck",
".",
"Port",
")",
"\n",
"}",
"\n\n",
"if",
"ck",
".",
"SendNotificationWhenDown",
"!=",
"0",
"{",
"m",
"[",
"\"",
"\"",
"]",
"=",
"strconv",
".",
"Itoa",
"(",
"ck",
".",
"SendNotificationWhenDown",
")",
"\n",
"}",
"\n\n",
"if",
"ck",
".",
"ResponseTimeThreshold",
"!=",
"0",
"{",
"m",
"[",
"\"",
"\"",
"]",
"=",
"strconv",
".",
"Itoa",
"(",
"ck",
".",
"ResponseTimeThreshold",
")",
"\n",
"}",
"\n\n",
"// ShouldContain and ShouldNotContain are mutually exclusive.",
"// But we must define one so they can be emptied if required.",
"if",
"ck",
".",
"ShouldContain",
"!=",
"\"",
"\"",
"{",
"m",
"[",
"\"",
"\"",
"]",
"=",
"ck",
".",
"ShouldContain",
"\n",
"}",
"else",
"{",
"m",
"[",
"\"",
"\"",
"]",
"=",
"ck",
".",
"ShouldNotContain",
"\n",
"}",
"\n\n",
"// Convert auth",
"if",
"ck",
".",
"Username",
"!=",
"\"",
"\"",
"{",
"m",
"[",
"\"",
"\"",
"]",
"=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"ck",
".",
"Username",
",",
"ck",
".",
"Password",
")",
"\n",
"}",
"\n\n",
"// Convert headers",
"var",
"headers",
"[",
"]",
"string",
"\n",
"for",
"k",
":=",
"range",
"ck",
".",
"RequestHeaders",
"{",
"headers",
"=",
"append",
"(",
"headers",
",",
"k",
")",
"\n",
"}",
"\n",
"sort",
".",
"Strings",
"(",
"headers",
")",
"\n",
"for",
"i",
",",
"k",
":=",
"range",
"headers",
"{",
"m",
"[",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"i",
")",
"]",
"=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"k",
",",
"ck",
".",
"RequestHeaders",
"[",
"k",
"]",
")",
"\n",
"}",
"\n\n",
"return",
"m",
"\n",
"}"
] |
// PutParams returns a map of parameters for an HttpCheck that can be sent along
// with an HTTP PUT request.
|
[
"PutParams",
"returns",
"a",
"map",
"of",
"parameters",
"for",
"an",
"HttpCheck",
"that",
"can",
"be",
"sent",
"along",
"with",
"an",
"HTTP",
"PUT",
"request",
"."
] |
017c8281f6d1a98515f8575e5152e02f545a5553
|
https://github.com/russellcardullo/go-pingdom/blob/017c8281f6d1a98515f8575e5152e02f545a5553/pingdom/check_types.go#L84-L139
|
17,842 |
russellcardullo/go-pingdom
|
pingdom/check_types.go
|
PostParams
|
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
|
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
}
|
[
"func",
"(",
"ck",
"*",
"HttpCheck",
")",
"PostParams",
"(",
")",
"map",
"[",
"string",
"]",
"string",
"{",
"params",
":=",
"ck",
".",
"PutParams",
"(",
")",
"\n\n",
"for",
"k",
",",
"v",
":=",
"range",
"params",
"{",
"if",
"v",
"==",
"\"",
"\"",
"{",
"delete",
"(",
"params",
",",
"k",
")",
"\n",
"}",
"\n",
"}",
"\n",
"params",
"[",
"\"",
"\"",
"]",
"=",
"\"",
"\"",
"\n\n",
"return",
"params",
"\n",
"}"
] |
// PostParams returns a map of parameters for an HttpCheck that can be sent along
// with an HTTP POST request. They are the same than the Put params, but
// empty strings cleared out, to avoid Pingdom API reject the request.
|
[
"PostParams",
"returns",
"a",
"map",
"of",
"parameters",
"for",
"an",
"HttpCheck",
"that",
"can",
"be",
"sent",
"along",
"with",
"an",
"HTTP",
"POST",
"request",
".",
"They",
"are",
"the",
"same",
"than",
"the",
"Put",
"params",
"but",
"empty",
"strings",
"cleared",
"out",
"to",
"avoid",
"Pingdom",
"API",
"reject",
"the",
"request",
"."
] |
017c8281f6d1a98515f8575e5152e02f545a5553
|
https://github.com/russellcardullo/go-pingdom/blob/017c8281f6d1a98515f8575e5152e02f545a5553/pingdom/check_types.go#L144-L155
|
17,843 |
russellcardullo/go-pingdom
|
pingdom/check_types.go
|
Valid
|
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
|
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
}
|
[
"func",
"(",
"ck",
"*",
"HttpCheck",
")",
"Valid",
"(",
")",
"error",
"{",
"if",
"ck",
".",
"Name",
"==",
"\"",
"\"",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"if",
"ck",
".",
"Hostname",
"==",
"\"",
"\"",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"if",
"ck",
".",
"Resolution",
"!=",
"1",
"&&",
"ck",
".",
"Resolution",
"!=",
"5",
"&&",
"ck",
".",
"Resolution",
"!=",
"15",
"&&",
"ck",
".",
"Resolution",
"!=",
"30",
"&&",
"ck",
".",
"Resolution",
"!=",
"60",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"ck",
".",
"Resolution",
")",
"\n",
"}",
"\n\n",
"if",
"ck",
".",
"ShouldContain",
"!=",
"\"",
"\"",
"&&",
"ck",
".",
"ShouldNotContain",
"!=",
"\"",
"\"",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] |
// Valid determines whether the HttpCheck contains valid fields. This can be
// used to guard against sending illegal values to the Pingdom API.
|
[
"Valid",
"determines",
"whether",
"the",
"HttpCheck",
"contains",
"valid",
"fields",
".",
"This",
"can",
"be",
"used",
"to",
"guard",
"against",
"sending",
"illegal",
"values",
"to",
"the",
"Pingdom",
"API",
"."
] |
017c8281f6d1a98515f8575e5152e02f545a5553
|
https://github.com/russellcardullo/go-pingdom/blob/017c8281f6d1a98515f8575e5152e02f545a5553/pingdom/check_types.go#L159-L178
|
17,844 |
russellcardullo/go-pingdom
|
pingdom/check_types.go
|
PutParams
|
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
|
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
}
|
[
"func",
"(",
"ck",
"*",
"PingCheck",
")",
"PutParams",
"(",
")",
"map",
"[",
"string",
"]",
"string",
"{",
"m",
":=",
"map",
"[",
"string",
"]",
"string",
"{",
"\"",
"\"",
":",
"ck",
".",
"Name",
",",
"\"",
"\"",
":",
"ck",
".",
"Hostname",
",",
"\"",
"\"",
":",
"strconv",
".",
"Itoa",
"(",
"ck",
".",
"Resolution",
")",
",",
"\"",
"\"",
":",
"strconv",
".",
"FormatBool",
"(",
"ck",
".",
"Paused",
")",
",",
"\"",
"\"",
":",
"strconv",
".",
"Itoa",
"(",
"ck",
".",
"NotifyAgainEvery",
")",
",",
"\"",
"\"",
":",
"strconv",
".",
"FormatBool",
"(",
"ck",
".",
"NotifyWhenBackup",
")",
",",
"\"",
"\"",
":",
"intListToCDString",
"(",
"ck",
".",
"IntegrationIds",
")",
",",
"\"",
"\"",
":",
"ck",
".",
"ProbeFilters",
",",
"\"",
"\"",
":",
"intListToCDString",
"(",
"ck",
".",
"UserIds",
")",
",",
"\"",
"\"",
":",
"intListToCDString",
"(",
"ck",
".",
"TeamIds",
")",
",",
"}",
"\n\n",
"if",
"ck",
".",
"SendNotificationWhenDown",
"!=",
"0",
"{",
"m",
"[",
"\"",
"\"",
"]",
"=",
"strconv",
".",
"Itoa",
"(",
"ck",
".",
"SendNotificationWhenDown",
")",
"\n",
"}",
"\n\n",
"if",
"ck",
".",
"ResponseTimeThreshold",
"!=",
"0",
"{",
"m",
"[",
"\"",
"\"",
"]",
"=",
"strconv",
".",
"Itoa",
"(",
"ck",
".",
"ResponseTimeThreshold",
")",
"\n",
"}",
"\n\n",
"return",
"m",
"\n",
"}"
] |
// PutParams returns a map of parameters for a PingCheck that can be sent along
// with an HTTP PUT request.
|
[
"PutParams",
"returns",
"a",
"map",
"of",
"parameters",
"for",
"a",
"PingCheck",
"that",
"can",
"be",
"sent",
"along",
"with",
"an",
"HTTP",
"PUT",
"request",
"."
] |
017c8281f6d1a98515f8575e5152e02f545a5553
|
https://github.com/russellcardullo/go-pingdom/blob/017c8281f6d1a98515f8575e5152e02f545a5553/pingdom/check_types.go#L182-L205
|
17,845 |
russellcardullo/go-pingdom
|
pingdom/check_types.go
|
Valid
|
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
|
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
}
|
[
"func",
"(",
"ck",
"*",
"PingCheck",
")",
"Valid",
"(",
")",
"error",
"{",
"if",
"ck",
".",
"Name",
"==",
"\"",
"\"",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"if",
"ck",
".",
"Hostname",
"==",
"\"",
"\"",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"if",
"ck",
".",
"Resolution",
"!=",
"1",
"&&",
"ck",
".",
"Resolution",
"!=",
"5",
"&&",
"ck",
".",
"Resolution",
"!=",
"15",
"&&",
"ck",
".",
"Resolution",
"!=",
"30",
"&&",
"ck",
".",
"Resolution",
"!=",
"60",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"ck",
".",
"Resolution",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// Valid determines whether the PingCheck contains valid fields. This can be
// used to guard against sending illegal values to the Pingdom API.
|
[
"Valid",
"determines",
"whether",
"the",
"PingCheck",
"contains",
"valid",
"fields",
".",
"This",
"can",
"be",
"used",
"to",
"guard",
"against",
"sending",
"illegal",
"values",
"to",
"the",
"Pingdom",
"API",
"."
] |
017c8281f6d1a98515f8575e5152e02f545a5553
|
https://github.com/russellcardullo/go-pingdom/blob/017c8281f6d1a98515f8575e5152e02f545a5553/pingdom/check_types.go#L224-L238
|
17,846 |
russellcardullo/go-pingdom
|
pingdom/check_types.go
|
PutParams
|
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
|
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
}
|
[
"func",
"(",
"ck",
"*",
"TCPCheck",
")",
"PutParams",
"(",
")",
"map",
"[",
"string",
"]",
"string",
"{",
"m",
":=",
"map",
"[",
"string",
"]",
"string",
"{",
"\"",
"\"",
":",
"ck",
".",
"Name",
",",
"\"",
"\"",
":",
"ck",
".",
"Hostname",
",",
"\"",
"\"",
":",
"strconv",
".",
"Itoa",
"(",
"ck",
".",
"Resolution",
")",
",",
"\"",
"\"",
":",
"strconv",
".",
"FormatBool",
"(",
"ck",
".",
"Paused",
")",
",",
"\"",
"\"",
":",
"strconv",
".",
"Itoa",
"(",
"ck",
".",
"NotifyAgainEvery",
")",
",",
"\"",
"\"",
":",
"strconv",
".",
"FormatBool",
"(",
"ck",
".",
"NotifyWhenBackup",
")",
",",
"\"",
"\"",
":",
"intListToCDString",
"(",
"ck",
".",
"IntegrationIds",
")",
",",
"\"",
"\"",
":",
"ck",
".",
"ProbeFilters",
",",
"\"",
"\"",
":",
"ck",
".",
"Tags",
",",
"\"",
"\"",
":",
"intListToCDString",
"(",
"ck",
".",
"UserIds",
")",
",",
"\"",
"\"",
":",
"intListToCDString",
"(",
"ck",
".",
"TeamIds",
")",
",",
"\"",
"\"",
":",
"strconv",
".",
"Itoa",
"(",
"ck",
".",
"Port",
")",
",",
"}",
"\n\n",
"if",
"ck",
".",
"SendNotificationWhenDown",
"!=",
"0",
"{",
"m",
"[",
"\"",
"\"",
"]",
"=",
"strconv",
".",
"Itoa",
"(",
"ck",
".",
"SendNotificationWhenDown",
")",
"\n",
"}",
"\n\n",
"if",
"ck",
".",
"StringToSend",
"!=",
"\"",
"\"",
"{",
"m",
"[",
"\"",
"\"",
"]",
"=",
"ck",
".",
"StringToSend",
"\n",
"}",
"\n\n",
"if",
"ck",
".",
"StringToExpect",
"!=",
"\"",
"\"",
"{",
"m",
"[",
"\"",
"\"",
"]",
"=",
"ck",
".",
"StringToExpect",
"\n",
"}",
"\n\n",
"return",
"m",
"\n",
"}"
] |
// PutParams returns a map of parameters for a TCPCheck that can be sent along
// with an HTTP PUT request.
|
[
"PutParams",
"returns",
"a",
"map",
"of",
"parameters",
"for",
"a",
"TCPCheck",
"that",
"can",
"be",
"sent",
"along",
"with",
"an",
"HTTP",
"PUT",
"request",
"."
] |
017c8281f6d1a98515f8575e5152e02f545a5553
|
https://github.com/russellcardullo/go-pingdom/blob/017c8281f6d1a98515f8575e5152e02f545a5553/pingdom/check_types.go#L242-L271
|
17,847 |
russellcardullo/go-pingdom
|
pingdom/check_types.go
|
Valid
|
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
|
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
}
|
[
"func",
"(",
"ck",
"*",
"TCPCheck",
")",
"Valid",
"(",
")",
"error",
"{",
"if",
"ck",
".",
"Name",
"==",
"\"",
"\"",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"if",
"ck",
".",
"Hostname",
"==",
"\"",
"\"",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"if",
"ck",
".",
"Resolution",
"!=",
"1",
"&&",
"ck",
".",
"Resolution",
"!=",
"5",
"&&",
"ck",
".",
"Resolution",
"!=",
"15",
"&&",
"ck",
".",
"Resolution",
"!=",
"30",
"&&",
"ck",
".",
"Resolution",
"!=",
"60",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"ck",
".",
"Resolution",
")",
"\n",
"}",
"\n\n",
"if",
"ck",
".",
"Port",
"<",
"1",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] |
// Valid determines whether the TCPCheck contains valid fields. This can be
// used to guard against sending illegal values to the Pingdom API.
|
[
"Valid",
"determines",
"whether",
"the",
"TCPCheck",
"contains",
"valid",
"fields",
".",
"This",
"can",
"be",
"used",
"to",
"guard",
"against",
"sending",
"illegal",
"values",
"to",
"the",
"Pingdom",
"API",
"."
] |
017c8281f6d1a98515f8575e5152e02f545a5553
|
https://github.com/russellcardullo/go-pingdom/blob/017c8281f6d1a98515f8575e5152e02f545a5553/pingdom/check_types.go#L290-L309
|
17,848 |
russellcardullo/go-pingdom
|
pingdom/check_types.go
|
Valid
|
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
|
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
}
|
[
"func",
"(",
"csr",
"SummaryPerformanceRequest",
")",
"Valid",
"(",
")",
"error",
"{",
"if",
"csr",
".",
"Id",
"==",
"0",
"{",
"return",
"ErrMissingId",
"\n",
"}",
"\n\n",
"if",
"csr",
".",
"Resolution",
"!=",
"\"",
"\"",
"&&",
"csr",
".",
"Resolution",
"!=",
"\"",
"\"",
"&&",
"csr",
".",
"Resolution",
"!=",
"\"",
"\"",
"&&",
"csr",
".",
"Resolution",
"!=",
"\"",
"\"",
"{",
"return",
"ErrBadResolution",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// Valid determines whether a SummaryPerformanceRequest contains valid fields for the Pingdom API.
|
[
"Valid",
"determines",
"whether",
"a",
"SummaryPerformanceRequest",
"contains",
"valid",
"fields",
"for",
"the",
"Pingdom",
"API",
"."
] |
017c8281f6d1a98515f8575e5152e02f545a5553
|
https://github.com/russellcardullo/go-pingdom/blob/017c8281f6d1a98515f8575e5152e02f545a5553/pingdom/check_types.go#L324-L333
|
17,849 |
russellcardullo/go-pingdom
|
pingdom/check_types.go
|
GetParams
|
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
|
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
}
|
[
"func",
"(",
"csr",
"SummaryPerformanceRequest",
")",
"GetParams",
"(",
")",
"(",
"params",
"map",
"[",
"string",
"]",
"string",
")",
"{",
"params",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"string",
")",
"\n\n",
"if",
"csr",
".",
"Resolution",
"!=",
"\"",
"\"",
"{",
"params",
"[",
"\"",
"\"",
"]",
"=",
"csr",
".",
"Resolution",
"\n",
"}",
"\n\n",
"if",
"csr",
".",
"IncludeUptime",
"{",
"params",
"[",
"\"",
"\"",
"]",
"=",
"\"",
"\"",
"\n",
"}",
"\n\n",
"return",
"\n",
"}"
] |
// GetParams returns a map of params for a Pingdom SummaryPerformanceRequest.
|
[
"GetParams",
"returns",
"a",
"map",
"of",
"params",
"for",
"a",
"Pingdom",
"SummaryPerformanceRequest",
"."
] |
017c8281f6d1a98515f8575e5152e02f545a5553
|
https://github.com/russellcardullo/go-pingdom/blob/017c8281f6d1a98515f8575e5152e02f545a5553/pingdom/check_types.go#L336-L348
|
17,850 |
multiformats/go-multiaddr-dns
|
resolve.go
|
matchDnsaddr
|
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
|
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
}
|
[
"func",
"matchDnsaddr",
"(",
"maddr",
"ma",
".",
"Multiaddr",
",",
"trailer",
"[",
"]",
"ma",
".",
"Multiaddr",
")",
"bool",
"{",
"parts",
":=",
"ma",
".",
"Split",
"(",
"maddr",
")",
"\n",
"if",
"ma",
".",
"Join",
"(",
"parts",
"[",
"len",
"(",
"parts",
")",
"-",
"len",
"(",
"trailer",
")",
":",
"]",
"...",
")",
".",
"Equal",
"(",
"ma",
".",
"Join",
"(",
"trailer",
"...",
")",
")",
"{",
"return",
"true",
"\n",
"}",
"\n",
"return",
"false",
"\n",
"}"
] |
// XXX probably insecure
|
[
"XXX",
"probably",
"insecure"
] |
7d0de25ce05c9294aa44f320c03c7e85e11bbb0b
|
https://github.com/multiformats/go-multiaddr-dns/blob/7d0de25ce05c9294aa44f320c03c7e85e11bbb0b/resolve.go#L175-L181
|
17,851 |
fd/go-nat
|
nat.go
|
DiscoverGateway
|
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
|
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
}
}
|
[
"func",
"DiscoverGateway",
"(",
")",
"(",
"NAT",
",",
"error",
")",
"{",
"select",
"{",
"case",
"nat",
":=",
"<-",
"discoverUPNP_IG1",
"(",
")",
":",
"return",
"nat",
",",
"nil",
"\n",
"case",
"nat",
":=",
"<-",
"discoverUPNP_IG2",
"(",
")",
":",
"return",
"nat",
",",
"nil",
"\n",
"case",
"nat",
":=",
"<-",
"discoverUPNP_GenIGDev",
"(",
")",
":",
"return",
"nat",
",",
"nil",
"\n",
"case",
"nat",
":=",
"<-",
"discoverNATPMP",
"(",
")",
":",
"return",
"nat",
",",
"nil",
"\n",
"case",
"<-",
"time",
".",
"After",
"(",
"10",
"*",
"time",
".",
"Second",
")",
":",
"return",
"nil",
",",
"ErrNoNATFound",
"\n",
"}",
"\n",
"}"
] |
// DiscoverGateway attempts to find a gateway device.
|
[
"DiscoverGateway",
"attempts",
"to",
"find",
"a",
"gateway",
"device",
"."
] |
51722233f3430d9a1218f4a47ae2dfa3a762428b
|
https://github.com/fd/go-nat/blob/51722233f3430d9a1218f4a47ae2dfa3a762428b/nat.go#L38-L51
|
17,852 |
argusdusty/Ferret
|
ferret.go
|
Insert
|
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
|
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
}
}
|
[
"func",
"(",
"IS",
"*",
"InvertedSuffix",
")",
"Insert",
"(",
"Word",
",",
"Result",
"string",
",",
"Data",
"interface",
"{",
"}",
")",
"{",
"Query",
":=",
"IS",
".",
"Converter",
"(",
"Word",
")",
"\n",
"low",
",",
"high",
":=",
"IS",
".",
"Search",
"(",
"Query",
")",
"\n",
"for",
"k",
":=",
"low",
";",
"k",
"<",
"high",
";",
"k",
"++",
"{",
"if",
"IS",
".",
"Results",
"[",
"IS",
".",
"WordIndex",
"[",
"k",
"]",
"]",
"==",
"Word",
"{",
"IS",
".",
"Values",
"[",
"IS",
".",
"WordIndex",
"[",
"k",
"]",
"]",
"=",
"Data",
"\n",
"return",
"\n",
"}",
"\n",
"}",
"\n",
"i",
":=",
"len",
"(",
"IS",
".",
"Words",
")",
"\n",
"IS",
".",
"Words",
"=",
"append",
"(",
"IS",
".",
"Words",
",",
"Query",
")",
"\n",
"Length",
":=",
"len",
"(",
"Query",
")",
"\n",
"IS",
".",
"Results",
"=",
"append",
"(",
"IS",
".",
"Results",
",",
"Result",
")",
"\n",
"IS",
".",
"Values",
"=",
"append",
"(",
"IS",
".",
"Values",
",",
"Data",
")",
"\n",
"for",
"j",
":=",
"0",
";",
"j",
"<",
"Length",
";",
"j",
"++",
"{",
"k",
",",
"_",
":=",
"IS",
".",
"Search",
"(",
"Query",
"[",
"j",
":",
"]",
")",
"\n",
"IS",
".",
"WordIndex",
"=",
"append",
"(",
"IS",
".",
"WordIndex",
",",
"0",
")",
"\n",
"copy",
"(",
"IS",
".",
"WordIndex",
"[",
"k",
"+",
"1",
":",
"]",
",",
"IS",
".",
"WordIndex",
"[",
"k",
":",
"]",
")",
"\n",
"IS",
".",
"WordIndex",
"[",
"k",
"]",
"=",
"i",
"\n",
"IS",
".",
"SuffixIndex",
"=",
"append",
"(",
"IS",
".",
"SuffixIndex",
",",
"0",
")",
"\n",
"copy",
"(",
"IS",
".",
"SuffixIndex",
"[",
"k",
"+",
"1",
":",
"]",
",",
"IS",
".",
"SuffixIndex",
"[",
"k",
":",
"]",
")",
"\n",
"IS",
".",
"SuffixIndex",
"[",
"k",
"]",
"=",
"j",
"\n",
"}",
"\n",
"}"
] |
// Insert adds a word to the dictionary that IS was built on.
// This is pretty slow, because of linear-time insertion into an array,
// so stick to New when you can
|
[
"Insert",
"adds",
"a",
"word",
"to",
"the",
"dictionary",
"that",
"IS",
"was",
"built",
"on",
".",
"This",
"is",
"pretty",
"slow",
"because",
"of",
"linear",
"-",
"time",
"insertion",
"into",
"an",
"array",
"so",
"stick",
"to",
"New",
"when",
"you",
"can"
] |
14de0b6c044512adfb53edf8f2b1578a621280fa
|
https://github.com/argusdusty/Ferret/blob/14de0b6c044512adfb53edf8f2b1578a621280fa/ferret.go#L102-L125
|
17,853 |
argusdusty/Ferret
|
errorcorrect.go
|
ErrorCorrect
|
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
|
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
}
|
[
"func",
"ErrorCorrect",
"(",
"Word",
"[",
"]",
"byte",
",",
"AllowedBytes",
"[",
"]",
"byte",
")",
"[",
"]",
"[",
"]",
"byte",
"{",
"results",
":=",
"make",
"(",
"[",
"]",
"[",
"]",
"byte",
",",
"0",
")",
"\n",
"N",
":=",
"len",
"(",
"Word",
")",
"\n",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"N",
";",
"i",
"++",
"{",
"t",
":=",
"Word",
"[",
"i",
"]",
"\n",
"// Remove Character",
"temp",
":=",
"make",
"(",
"[",
"]",
"byte",
",",
"N",
")",
"\n",
"copy",
"(",
"temp",
",",
"Word",
")",
"\n",
"temp",
"=",
"append",
"(",
"temp",
"[",
":",
"i",
"]",
",",
"temp",
"[",
"i",
"+",
"1",
":",
"]",
"...",
")",
"\n",
"results",
"=",
"append",
"(",
"results",
",",
"temp",
")",
"\n",
"if",
"i",
"!=",
"0",
"{",
"// Add Character",
"for",
"_",
",",
"c",
":=",
"range",
"AllowedBytes",
"{",
"temp",
":=",
"make",
"(",
"[",
"]",
"byte",
",",
"N",
")",
"\n",
"copy",
"(",
"temp",
",",
"Word",
")",
"\n",
"temp",
"=",
"append",
"(",
"temp",
"[",
":",
"i",
"]",
",",
"append",
"(",
"[",
"]",
"byte",
"{",
"c",
"}",
",",
"temp",
"[",
"i",
":",
"]",
"...",
")",
"...",
")",
"\n",
"results",
"=",
"append",
"(",
"results",
",",
"temp",
")",
"\n",
"}",
"\n",
"// Transpose Character",
"temp",
":=",
"make",
"(",
"[",
"]",
"byte",
",",
"N",
")",
"\n",
"copy",
"(",
"temp",
",",
"Word",
")",
"\n",
"temp",
"[",
"i",
"]",
",",
"temp",
"[",
"i",
"-",
"1",
"]",
"=",
"temp",
"[",
"i",
"-",
"1",
"]",
",",
"temp",
"[",
"i",
"]",
"\n",
"results",
"=",
"append",
"(",
"results",
",",
"temp",
")",
"\n",
"}",
"\n",
"// Insert Character",
"for",
"_",
",",
"c",
":=",
"range",
"AllowedBytes",
"{",
"if",
"c",
"==",
"t",
"{",
"continue",
"\n",
"}",
"\n",
"temp",
":=",
"make",
"(",
"[",
"]",
"byte",
",",
"N",
")",
"\n",
"copy",
"(",
"temp",
",",
"Word",
")",
"\n",
"temp",
"[",
"i",
"]",
"=",
"c",
"\n",
"results",
"=",
"append",
"(",
"results",
",",
"temp",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"results",
"\n",
"}"
] |
// ErrorCorrect returns all byte-arrays which are Levenshtein distance of 1 away from Word
// within an allowed array of byte characters.
|
[
"ErrorCorrect",
"returns",
"all",
"byte",
"-",
"arrays",
"which",
"are",
"Levenshtein",
"distance",
"of",
"1",
"away",
"from",
"Word",
"within",
"an",
"allowed",
"array",
"of",
"byte",
"characters",
"."
] |
14de0b6c044512adfb53edf8f2b1578a621280fa
|
https://github.com/argusdusty/Ferret/blob/14de0b6c044512adfb53edf8f2b1578a621280fa/errorcorrect.go#L60-L96
|
17,854 |
argusdusty/Ferret
|
unicodeconvert.go
|
ToASCII
|
func ToASCII(r rune) rune {
a, ok := UnicodeToASCII[r]
if ok {
return a
}
return r
}
|
go
|
func ToASCII(r rune) rune {
a, ok := UnicodeToASCII[r]
if ok {
return a
}
return r
}
|
[
"func",
"ToASCII",
"(",
"r",
"rune",
")",
"rune",
"{",
"a",
",",
"ok",
":=",
"UnicodeToASCII",
"[",
"r",
"]",
"\n",
"if",
"ok",
"{",
"return",
"a",
"\n",
"}",
"\n",
"return",
"r",
"\n",
"}"
] |
// ToASCII converts a single unicode rune to the ASCII equivalent using the UnicodeToASCII table
|
[
"ToASCII",
"converts",
"a",
"single",
"unicode",
"rune",
"to",
"the",
"ASCII",
"equivalent",
"using",
"the",
"UnicodeToASCII",
"table"
] |
14de0b6c044512adfb53edf8f2b1578a621280fa
|
https://github.com/argusdusty/Ferret/blob/14de0b6c044512adfb53edf8f2b1578a621280fa/unicodeconvert.go#L48-L54
|
17,855 |
argusdusty/Ferret
|
unicodeconvert.go
|
UnicodeToLowerASCII
|
func UnicodeToLowerASCII(s string) []byte {
return []byte(strings.Map(func(r rune) rune { return unicode.ToLower(ToASCII(r)) }, s))
}
|
go
|
func UnicodeToLowerASCII(s string) []byte {
return []byte(strings.Map(func(r rune) rune { return unicode.ToLower(ToASCII(r)) }, s))
}
|
[
"func",
"UnicodeToLowerASCII",
"(",
"s",
"string",
")",
"[",
"]",
"byte",
"{",
"return",
"[",
"]",
"byte",
"(",
"strings",
".",
"Map",
"(",
"func",
"(",
"r",
"rune",
")",
"rune",
"{",
"return",
"unicode",
".",
"ToLower",
"(",
"ToASCII",
"(",
"r",
")",
")",
"}",
",",
"s",
")",
")",
"\n",
"}"
] |
// UnicodeToLowerASCII converts a unicode string to ASCII bytes using the UnicodeToASCII table
|
[
"UnicodeToLowerASCII",
"converts",
"a",
"unicode",
"string",
"to",
"ASCII",
"bytes",
"using",
"the",
"UnicodeToASCII",
"table"
] |
14de0b6c044512adfb53edf8f2b1578a621280fa
|
https://github.com/argusdusty/Ferret/blob/14de0b6c044512adfb53edf8f2b1578a621280fa/unicodeconvert.go#L57-L59
|
17,856 |
libopenstorage/gossip
|
api.go
|
New
|
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
|
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
}
|
[
"func",
"New",
"(",
"ip",
"string",
",",
"selfNodeId",
"types",
".",
"NodeId",
",",
"genNumber",
"uint64",
",",
"gossipIntervals",
"types",
".",
"GossipIntervals",
",",
"gossipVersion",
"string",
",",
"clusterId",
"string",
",",
"selfFailureDomain",
"string",
",",
")",
"Gossiper",
"{",
"g",
":=",
"new",
"(",
"proto",
".",
"GossiperImpl",
")",
"\n",
"g",
".",
"Init",
"(",
"ip",
",",
"selfNodeId",
",",
"genNumber",
",",
"gossipIntervals",
",",
"gossipVersion",
",",
"clusterId",
",",
"selfFailureDomain",
")",
"\n",
"return",
"g",
"\n",
"}"
] |
// New returns an initialized Gossip node
// which identifies itself with the given ip
|
[
"New",
"returns",
"an",
"initialized",
"Gossip",
"node",
"which",
"identifies",
"itself",
"with",
"the",
"given",
"ip"
] |
618a8c84303a0bd7cd56637c579b216294301586
|
https://github.com/libopenstorage/gossip/blob/618a8c84303a0bd7cd56637c579b216294301586/api.go#L99-L111
|
17,857 |
libopenstorage/gossip
|
proto/gossip_delegates.go
|
NodeMeta
|
func (gd *GossipDelegate) NodeMeta(limit int) []byte {
msg := gd.MetaInfo()
msgBytes, _ := gd.convertToBytes(msg)
return msgBytes
}
|
go
|
func (gd *GossipDelegate) NodeMeta(limit int) []byte {
msg := gd.MetaInfo()
msgBytes, _ := gd.convertToBytes(msg)
return msgBytes
}
|
[
"func",
"(",
"gd",
"*",
"GossipDelegate",
")",
"NodeMeta",
"(",
"limit",
"int",
")",
"[",
"]",
"byte",
"{",
"msg",
":=",
"gd",
".",
"MetaInfo",
"(",
")",
"\n",
"msgBytes",
",",
"_",
":=",
"gd",
".",
"convertToBytes",
"(",
"msg",
")",
"\n",
"return",
"msgBytes",
"\n",
"}"
] |
// NodeMeta is used to retrieve meta-data about the current node
// when broadcasting an alive message. It's length is limited to
// the given byte size. This metadata is available in the Node structure.
|
[
"NodeMeta",
"is",
"used",
"to",
"retrieve",
"meta",
"-",
"data",
"about",
"the",
"current",
"node",
"when",
"broadcasting",
"an",
"alive",
"message",
".",
"It",
"s",
"length",
"is",
"limited",
"to",
"the",
"given",
"byte",
"size",
".",
"This",
"metadata",
"is",
"available",
"in",
"the",
"Node",
"structure",
"."
] |
618a8c84303a0bd7cd56637c579b216294301586
|
https://github.com/libopenstorage/gossip/blob/618a8c84303a0bd7cd56637c579b216294301586/proto/gossip_delegates.go#L131-L135
|
17,858 |
libopenstorage/gossip
|
proto/gossip_delegates.go
|
NotifyJoin
|
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
|
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))
}
}
|
[
"func",
"(",
"gd",
"*",
"GossipDelegate",
")",
"NotifyJoin",
"(",
"node",
"*",
"memberlist",
".",
"Node",
")",
"{",
"// Ignore self NotifyJoin",
"nodeName",
":=",
"gd",
".",
"parseMemberlistNodeName",
"(",
"node",
".",
"Name",
")",
"\n",
"if",
"nodeName",
"==",
"gd",
".",
"nodeId",
"{",
"return",
"\n",
"}",
"\n\n",
"gd",
".",
"updateGossipTs",
"(",
")",
"\n\n",
"// 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",
")",
")",
"\n",
"}",
"\n",
"}"
] |
// NotifyJoin is invoked when a node is detected to have joined.
// The Node argument must not be modified.
|
[
"NotifyJoin",
"is",
"invoked",
"when",
"a",
"node",
"is",
"detected",
"to",
"have",
"joined",
".",
"The",
"Node",
"argument",
"must",
"not",
"be",
"modified",
"."
] |
618a8c84303a0bd7cd56637c579b216294301586
|
https://github.com/libopenstorage/gossip/blob/618a8c84303a0bd7cd56637c579b216294301586/proto/gossip_delegates.go#L206-L221
|
17,859 |
libopenstorage/gossip
|
proto/gossip_delegates.go
|
NotifyLeave
|
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
|
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
}
|
[
"func",
"(",
"gd",
"*",
"GossipDelegate",
")",
"NotifyLeave",
"(",
"node",
"*",
"memberlist",
".",
"Node",
")",
"{",
"nodeName",
":=",
"gd",
".",
"parseMemberlistNodeName",
"(",
"node",
".",
"Name",
")",
"\n",
"if",
"nodeName",
"==",
"gd",
".",
"nodeId",
"{",
"gd",
".",
"triggerStateEvent",
"(",
"types",
".",
"SELF_LEAVE",
")",
"\n",
"}",
"else",
"{",
"if",
"gd",
".",
"quorumProvider",
".",
"Type",
"(",
")",
"==",
"types",
".",
"QUORUM_PROVIDER_FAILURE_DOMAINS",
"{",
"go",
"func",
"(",
")",
"{",
"isSuspect",
":=",
"gd",
".",
"isClusterDomainSuspectDown",
"(",
"types",
".",
"NodeId",
"(",
"nodeName",
")",
")",
"\n",
"if",
"isSuspect",
"{",
"gd",
".",
"setNodeAsSuspectOffline",
"(",
"nodeName",
")",
"\n",
"}",
"else",
"{",
"gd",
".",
"setNodeOffline",
"(",
"nodeName",
")",
"\n",
"}",
"\n",
"}",
"(",
")",
"\n",
"}",
"else",
"{",
"gd",
".",
"setNodeOffline",
"(",
"nodeName",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"gd",
".",
"updateGossipTs",
"(",
")",
"\n",
"return",
"\n",
"}"
] |
// NotifyLeave is invoked when a node is detected to have left.
// The Node argument must not be modified.
|
[
"NotifyLeave",
"is",
"invoked",
"when",
"a",
"node",
"is",
"detected",
"to",
"have",
"left",
".",
"The",
"Node",
"argument",
"must",
"not",
"be",
"modified",
"."
] |
618a8c84303a0bd7cd56637c579b216294301586
|
https://github.com/libopenstorage/gossip/blob/618a8c84303a0bd7cd56637c579b216294301586/proto/gossip_delegates.go#L225-L246
|
17,860 |
libopenstorage/gossip
|
proto/gossip_delegates.go
|
isClusterDomainSuspectDown
|
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
|
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
}
|
[
"func",
"(",
"gd",
"*",
"GossipDelegate",
")",
"isClusterDomainSuspectDown",
"(",
"nodeId",
"types",
".",
"NodeId",
")",
"bool",
"{",
"nodeInfo",
",",
"err",
":=",
"gd",
".",
"GetLocalNodeInfo",
"(",
"nodeId",
")",
"\n",
"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",
"\n",
"}",
"\n",
"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",
"\n",
"}",
"\n",
"nodeList",
":=",
"gd",
".",
"getNodesFromClusterDomain",
"(",
"nodeInfo",
".",
"ClusterDomain",
")",
"\n",
"for",
"fdNodeId",
",",
"_",
":=",
"range",
"nodeList",
"{",
"if",
"fdNodeId",
"==",
"nodeId",
"||",
"types",
".",
"NodeId",
"(",
"gd",
".",
"nodeId",
")",
"==",
"nodeId",
"{",
"// No need of pinging ourselves or the suspected node.",
"continue",
"\n",
"}",
"\n",
"// 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",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"// If we cannot find this node's entry in our map",
"// there is no point in pinging it",
"continue",
"\n",
"}",
"\n",
"logrus",
".",
"Infof",
"(",
"\"",
"\"",
",",
"fdNodeId",
",",
"nodeInfo",
".",
"Addr",
",",
"nodeId",
")",
"\n",
"_",
",",
"pingErr",
":=",
"gd",
".",
"ping",
"(",
"fdNodeId",
",",
"nodeInfo",
".",
"Addr",
")",
"\n",
"if",
"pingErr",
"!=",
"nil",
"{",
"// Ping to a node in the same cluster domain as the suspected node",
"// failed. Try another node",
"logrus",
".",
"Infof",
"(",
"\"",
"\"",
"+",
"\"",
"\"",
",",
"fdNodeId",
",",
"nodeInfo",
".",
"Addr",
",",
"nodeInfo",
".",
"ClusterDomain",
",",
"pingErr",
")",
"\n",
"continue",
"\n",
"}",
"else",
"{",
"// Ping to a node in the same cluster domain succeeded",
"// The cluster domain is online and only this node is offline",
"return",
"false",
"\n",
"}",
"\n",
"}",
"\n",
"// All the pings failed. The cluster domain is down. Put the node in suspect before marking it down.",
"return",
"true",
"\n",
"}"
] |
// isClusterDomainSuspectDown returns truewhen a peer node should be put in suspected offline state
// For the given nodeId, it finds out all its peers from
// the same cluster domain. If even one ping to such peer node succeeds it assumes that
// only the suspected node is down and the whole cluster domain is still operational.
// If all the pings to peer nodes in that cluster domain fail we put the node in
// suspect down state
|
[
"isClusterDomainSuspectDown",
"returns",
"truewhen",
"a",
"peer",
"node",
"should",
"be",
"put",
"in",
"suspected",
"offline",
"state",
"For",
"the",
"given",
"nodeId",
"it",
"finds",
"out",
"all",
"its",
"peers",
"from",
"the",
"same",
"cluster",
"domain",
".",
"If",
"even",
"one",
"ping",
"to",
"such",
"peer",
"node",
"succeeds",
"it",
"assumes",
"that",
"only",
"the",
"suspected",
"node",
"is",
"down",
"and",
"the",
"whole",
"cluster",
"domain",
"is",
"still",
"operational",
".",
"If",
"all",
"the",
"pings",
"to",
"peer",
"nodes",
"in",
"that",
"cluster",
"domain",
"fail",
"we",
"put",
"the",
"node",
"in",
"suspect",
"down",
"state"
] |
618a8c84303a0bd7cd56637c579b216294301586
|
https://github.com/libopenstorage/gossip/blob/618a8c84303a0bd7cd56637c579b216294301586/proto/gossip_delegates.go#L429-L472
|
17,861 |
libopenstorage/gossip
|
pkg/probation/probation.go
|
NewProbationManager
|
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
|
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
}
|
[
"func",
"NewProbationManager",
"(",
"name",
"string",
",",
"probationTimeout",
"time",
".",
"Duration",
",",
"pcf",
"CallbackFn",
",",
")",
"Probation",
"{",
"if",
"sched",
".",
"Instance",
"(",
")",
"==",
"nil",
"{",
"sched",
".",
"Init",
"(",
"1",
"*",
"time",
".",
"Second",
")",
"\n",
"}",
"\n",
"p",
":=",
"&",
"probation",
"{",
"name",
":",
"name",
",",
"probationTimeout",
":",
"probationTimeout",
",",
"pcf",
":",
"pcf",
",",
"probationTasks",
":",
"make",
"(",
"map",
"[",
"string",
"]",
"sched",
".",
"TaskID",
")",
",",
"schedInst",
":",
"sched",
".",
"Instance",
"(",
")",
",",
"}",
"\n",
"return",
"p",
"\n",
"}"
] |
// NewProbationManager returns the default implementation of Probation interface
// It takes in a name to be associated with this probation manager and a
// ProbationCallbackFn
|
[
"NewProbationManager",
"returns",
"the",
"default",
"implementation",
"of",
"Probation",
"interface",
"It",
"takes",
"in",
"a",
"name",
"to",
"be",
"associated",
"with",
"this",
"probation",
"manager",
"and",
"a",
"ProbationCallbackFn"
] |
618a8c84303a0bd7cd56637c579b216294301586
|
https://github.com/libopenstorage/gossip/blob/618a8c84303a0bd7cd56637c579b216294301586/pkg/probation/probation.go#L43-L59
|
17,862 |
libopenstorage/gossip
|
proto/state/quorum_failure_domains.go
|
isDomainActive
|
func (f *failureDomainsQuorum) isDomainActive(ipDomain string) bool {
isActive, _ := f.activeMap[ipDomain]
if isActive == types.CLUSTER_DOMAIN_STATE_ACTIVE {
return true
}
return false
}
|
go
|
func (f *failureDomainsQuorum) isDomainActive(ipDomain string) bool {
isActive, _ := f.activeMap[ipDomain]
if isActive == types.CLUSTER_DOMAIN_STATE_ACTIVE {
return true
}
return false
}
|
[
"func",
"(",
"f",
"*",
"failureDomainsQuorum",
")",
"isDomainActive",
"(",
"ipDomain",
"string",
")",
"bool",
"{",
"isActive",
",",
"_",
":=",
"f",
".",
"activeMap",
"[",
"ipDomain",
"]",
"\n",
"if",
"isActive",
"==",
"types",
".",
"CLUSTER_DOMAIN_STATE_ACTIVE",
"{",
"return",
"true",
"\n",
"}",
"\n",
"return",
"false",
"\n",
"}"
] |
// isDomainActive returns true if the input failure domains is a part of
// of an active domain list
|
[
"isDomainActive",
"returns",
"true",
"if",
"the",
"input",
"failure",
"domains",
"is",
"a",
"part",
"of",
"of",
"an",
"active",
"domain",
"list"
] |
618a8c84303a0bd7cd56637c579b216294301586
|
https://github.com/libopenstorage/gossip/blob/618a8c84303a0bd7cd56637c579b216294301586/proto/state/quorum_failure_domains.go#L65-L71
|
17,863 |
libopenstorage/gossip
|
proto/state/quorum.go
|
NewQuorumProvider
|
func NewQuorumProvider(
selfId types.NodeId,
provider types.QuorumProvider,
) Quorum {
if provider == types.QUORUM_PROVIDER_DEFAULT {
return &defaultQuorum{
selfId: selfId,
}
}
return &failureDomainsQuorum{
selfId: selfId,
}
}
|
go
|
func NewQuorumProvider(
selfId types.NodeId,
provider types.QuorumProvider,
) Quorum {
if provider == types.QUORUM_PROVIDER_DEFAULT {
return &defaultQuorum{
selfId: selfId,
}
}
return &failureDomainsQuorum{
selfId: selfId,
}
}
|
[
"func",
"NewQuorumProvider",
"(",
"selfId",
"types",
".",
"NodeId",
",",
"provider",
"types",
".",
"QuorumProvider",
",",
")",
"Quorum",
"{",
"if",
"provider",
"==",
"types",
".",
"QUORUM_PROVIDER_DEFAULT",
"{",
"return",
"&",
"defaultQuorum",
"{",
"selfId",
":",
"selfId",
",",
"}",
"\n",
"}",
"\n",
"return",
"&",
"failureDomainsQuorum",
"{",
"selfId",
":",
"selfId",
",",
"}",
"\n",
"}"
] |
// NewQuorumProvider returns tan implementation of Quorum interface based on
// the input type
|
[
"NewQuorumProvider",
"returns",
"tan",
"implementation",
"of",
"Quorum",
"interface",
"based",
"on",
"the",
"input",
"type"
] |
618a8c84303a0bd7cd56637c579b216294301586
|
https://github.com/libopenstorage/gossip/blob/618a8c84303a0bd7cd56637c579b216294301586/proto/state/quorum.go#L27-L39
|
17,864 |
hhkbp2/go-logging
|
handler_timed_rotating_file.go
|
computeRolloverTime
|
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
|
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
}
|
[
"func",
"(",
"self",
"*",
"TimedRotatingFileHandler",
")",
"computeRolloverTime",
"(",
"currentTime",
"time",
".",
"Time",
")",
"time",
".",
"Time",
"{",
"result",
":=",
"currentTime",
".",
"Add",
"(",
"self",
".",
"interval",
")",
"\n",
"// 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",
"==",
"\"",
"\"",
")",
"||",
"strings",
".",
"HasPrefix",
"(",
"self",
".",
"when",
",",
"\"",
"\"",
")",
"{",
"var",
"t",
"time",
".",
"Time",
"\n",
"if",
"self",
".",
"utc",
"{",
"t",
"=",
"currentTime",
".",
"UTC",
"(",
")",
"\n",
"}",
"else",
"{",
"t",
"=",
"currentTime",
".",
"Local",
"(",
")",
"\n",
"}",
"\n",
"dayStartTime",
":=",
"time",
".",
"Date",
"(",
"t",
".",
"Year",
"(",
")",
",",
"t",
".",
"Month",
"(",
")",
",",
"t",
".",
"Day",
"(",
")",
",",
"0",
",",
"0",
",",
"0",
",",
"0",
",",
"t",
".",
"Location",
"(",
")",
")",
"\n",
"result",
"=",
"currentTime",
".",
"Add",
"(",
"Day",
"-",
"t",
".",
"Sub",
"(",
"dayStartTime",
")",
")",
"\n",
"// 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",
",",
"\"",
"\"",
")",
"{",
"weekday",
":=",
"int",
"(",
"t",
".",
"Weekday",
"(",
")",
")",
"\n",
"if",
"weekday",
"!=",
"self",
".",
"weekday",
"{",
"var",
"daysToWait",
"int",
"\n",
"if",
"weekday",
"<",
"self",
".",
"weekday",
"{",
"daysToWait",
"=",
"self",
".",
"weekday",
"-",
"weekday",
"\n",
"}",
"else",
"{",
"daysToWait",
"=",
"6",
"-",
"weekday",
"+",
"self",
".",
"weekday",
"+",
"1",
"\n",
"}",
"\n",
"result",
"=",
"result",
".",
"Add",
"(",
"time",
".",
"Duration",
"(",
"int64",
"(",
"daysToWait",
")",
"*",
"int64",
"(",
"Day",
")",
")",
")",
"\n",
"// NOTE: we skip the daylight savings time issues here",
"// because time library in Golang doesn't support it.",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"result",
"\n",
"}"
] |
// Work out the rollover time based on the specified time.
|
[
"Work",
"out",
"the",
"rollover",
"time",
"based",
"on",
"the",
"specified",
"time",
"."
] |
65fcbf8cf388a708c9c36def03633ec62056d3f5
|
https://github.com/hhkbp2/go-logging/blob/65fcbf8cf388a708c9c36def03633ec62056d3f5/handler_timed_rotating_file.go#L125-L180
|
17,865 |
hhkbp2/go-logging
|
handler_timed_rotating_file.go
|
ShouldRollover
|
func (self *TimedRotatingFileHandler) ShouldRollover(
record *LogRecord) (bool, string) {
overTime := time.Now().After(self.rolloverTime)
return overTime, self.Format(record)
}
|
go
|
func (self *TimedRotatingFileHandler) ShouldRollover(
record *LogRecord) (bool, string) {
overTime := time.Now().After(self.rolloverTime)
return overTime, self.Format(record)
}
|
[
"func",
"(",
"self",
"*",
"TimedRotatingFileHandler",
")",
"ShouldRollover",
"(",
"record",
"*",
"LogRecord",
")",
"(",
"bool",
",",
"string",
")",
"{",
"overTime",
":=",
"time",
".",
"Now",
"(",
")",
".",
"After",
"(",
"self",
".",
"rolloverTime",
")",
"\n",
"return",
"overTime",
",",
"self",
".",
"Format",
"(",
"record",
")",
"\n",
"}"
] |
// Determine if rollover should occur.
|
[
"Determine",
"if",
"rollover",
"should",
"occur",
"."
] |
65fcbf8cf388a708c9c36def03633ec62056d3f5
|
https://github.com/hhkbp2/go-logging/blob/65fcbf8cf388a708c9c36def03633ec62056d3f5/handler_timed_rotating_file.go#L183-L188
|
17,866 |
hhkbp2/go-logging
|
handler_timed_rotating_file.go
|
getFilesToDelete
|
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
|
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
}
|
[
"func",
"(",
"self",
"*",
"TimedRotatingFileHandler",
")",
"getFilesToDelete",
"(",
")",
"(",
"[",
"]",
"string",
",",
"error",
")",
"{",
"dirName",
",",
"baseName",
":=",
"filepath",
".",
"Split",
"(",
"self",
".",
"GetFilePath",
"(",
")",
")",
"\n",
"fileInfos",
",",
"err",
":=",
"ioutil",
".",
"ReadDir",
"(",
"dirName",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"prefix",
":=",
"baseName",
"+",
"\"",
"\"",
"\n",
"pattern",
",",
"err",
":=",
"regexp",
".",
"Compile",
"(",
"self",
".",
"extMatch",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"var",
"fileNames",
"[",
"]",
"string",
"\n",
"for",
"_",
",",
"info",
":=",
"range",
"fileInfos",
"{",
"fileName",
":=",
"info",
".",
"Name",
"(",
")",
"\n",
"if",
"strings",
".",
"HasPrefix",
"(",
"fileName",
",",
"prefix",
")",
"{",
"suffix",
":=",
"fileName",
"[",
"len",
"(",
"prefix",
")",
":",
"]",
"\n",
"if",
"pattern",
".",
"MatchString",
"(",
"suffix",
")",
"{",
"fileNames",
"=",
"append",
"(",
"fileNames",
",",
"fileName",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"// no need to sort fileNames since ioutil.ReadDir() returns sorted list.",
"var",
"result",
"[",
"]",
"string",
"\n",
"if",
"uint32",
"(",
"len",
"(",
"fileNames",
")",
")",
"<",
"self",
".",
"backupCount",
"{",
"return",
"result",
",",
"nil",
"\n",
"}",
"\n",
"result",
"=",
"fileNames",
"[",
":",
"uint32",
"(",
"len",
"(",
"fileNames",
")",
")",
"-",
"self",
".",
"backupCount",
"]",
"\n",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"len",
"(",
"result",
")",
";",
"i",
"++",
"{",
"result",
"[",
"i",
"]",
"=",
"filepath",
".",
"Join",
"(",
"dirName",
",",
"result",
"[",
"i",
"]",
")",
"\n",
"}",
"\n",
"return",
"result",
",",
"nil",
"\n",
"}"
] |
// Determine the files to delete when rolling over.
|
[
"Determine",
"the",
"files",
"to",
"delete",
"when",
"rolling",
"over",
"."
] |
65fcbf8cf388a708c9c36def03633ec62056d3f5
|
https://github.com/hhkbp2/go-logging/blob/65fcbf8cf388a708c9c36def03633ec62056d3f5/handler_timed_rotating_file.go#L191-L222
|
17,867 |
hhkbp2/go-logging
|
handler_syslog.go
|
Emit
|
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
|
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
}
|
[
"func",
"(",
"self",
"*",
"SyslogHandler",
")",
"Emit",
"(",
"record",
"*",
"LogRecord",
")",
"error",
"{",
"message",
":=",
"self",
".",
"BaseHandler",
".",
"Format",
"(",
"record",
")",
"\n",
"var",
"err",
"error",
"\n",
"switch",
"record",
".",
"Level",
"{",
"case",
"LevelFatal",
":",
"err",
"=",
"self",
".",
"writer",
".",
"Crit",
"(",
"message",
")",
"\n",
"case",
"LevelError",
":",
"err",
"=",
"self",
".",
"writer",
".",
"Err",
"(",
"message",
")",
"\n",
"case",
"LevelWarn",
":",
"err",
"=",
"self",
".",
"writer",
".",
"Warning",
"(",
"message",
")",
"\n",
"case",
"LevelInfo",
":",
"err",
"=",
"self",
".",
"writer",
".",
"Info",
"(",
"message",
")",
"\n",
"case",
"LevelDebug",
":",
"err",
"=",
"self",
".",
"writer",
".",
"Debug",
"(",
"message",
")",
"\n",
"default",
":",
"_",
",",
"err",
"=",
"self",
".",
"writer",
".",
"Write",
"(",
"[",
"]",
"byte",
"(",
"message",
")",
")",
"\n",
"}",
"\n",
"return",
"err",
"\n",
"}"
] |
// Emit a record.
// The record is formatted, and then sent to the syslog server
// in specified log level.
|
[
"Emit",
"a",
"record",
".",
"The",
"record",
"is",
"formatted",
"and",
"then",
"sent",
"to",
"the",
"syslog",
"server",
"in",
"specified",
"log",
"level",
"."
] |
65fcbf8cf388a708c9c36def03633ec62056d3f5
|
https://github.com/hhkbp2/go-logging/blob/65fcbf8cf388a708c9c36def03633ec62056d3f5/handler_syslog.go#L65-L83
|
17,868 |
hhkbp2/go-logging
|
handler_rotating_file.go
|
NewBaseRotatingHandler
|
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
|
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
}
|
[
"func",
"NewBaseRotatingHandler",
"(",
"filepath",
"string",
",",
"mode",
",",
"bufferSize",
"int",
")",
"(",
"*",
"BaseRotatingHandler",
",",
"error",
")",
"{",
"fileHandler",
",",
"err",
":=",
"NewFileHandler",
"(",
"filepath",
",",
"mode",
",",
"bufferSize",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"object",
":=",
"&",
"BaseRotatingHandler",
"{",
"FileHandler",
":",
"fileHandler",
",",
"}",
"\n",
"Closer",
".",
"RemoveHandler",
"(",
"object",
".",
"FileHandler",
")",
"\n",
"Closer",
".",
"AddHandler",
"(",
"object",
")",
"\n",
"return",
"object",
",",
"nil",
"\n",
"}"
] |
// Initialize base rotating handler with specified filename for stream logging.
|
[
"Initialize",
"base",
"rotating",
"handler",
"with",
"specified",
"filename",
"for",
"stream",
"logging",
"."
] |
65fcbf8cf388a708c9c36def03633ec62056d3f5
|
https://github.com/hhkbp2/go-logging/blob/65fcbf8cf388a708c9c36def03633ec62056d3f5/handler_rotating_file.go#L37-L50
|
17,869 |
hhkbp2/go-logging
|
handler_rotating_file.go
|
RolloverEmit
|
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
|
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
}
|
[
"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",
")",
"\n",
"if",
"doRollover",
"{",
"if",
"err",
":=",
"handler",
".",
"Flush",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"if",
"err",
":=",
"handler",
".",
"DoRollover",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n",
"// Message already has a trailing '\\n'.",
"err",
":=",
"self",
".",
"GetStream",
"(",
")",
".",
"Write",
"(",
"message",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// A helper function for subclass to emit record.
|
[
"A",
"helper",
"function",
"for",
"subclass",
"to",
"emit",
"record",
"."
] |
65fcbf8cf388a708c9c36def03633ec62056d3f5
|
https://github.com/hhkbp2/go-logging/blob/65fcbf8cf388a708c9c36def03633ec62056d3f5/handler_rotating_file.go#L53-L74
|
17,870 |
hhkbp2/go-logging
|
handler_rotating_file.go
|
ShouldRollover
|
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
|
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
}
|
[
"func",
"(",
"self",
"*",
"RotatingFileHandler",
")",
"ShouldRollover",
"(",
"record",
"*",
"LogRecord",
")",
"(",
"bool",
",",
"string",
")",
"{",
"message",
":=",
"self",
".",
"Format",
"(",
"record",
")",
"\n",
"if",
"self",
".",
"maxBytes",
">",
"0",
"{",
"offset",
",",
"err",
":=",
"self",
".",
"GetStream",
"(",
")",
".",
"Tell",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"// don't trigger rollover action if we lose offset info",
"return",
"false",
",",
"message",
"\n",
"}",
"\n",
"if",
"(",
"uint64",
"(",
"offset",
")",
"+",
"uint64",
"(",
"len",
"(",
"message",
")",
")",
")",
">",
"self",
".",
"maxBytes",
"{",
"return",
"true",
",",
"message",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"false",
",",
"message",
"\n",
"}"
] |
// Determine if rollover should occur.
// Basically, see if the supplied record would cause the file to exceed the
// size limit we have.
|
[
"Determine",
"if",
"rollover",
"should",
"occur",
".",
"Basically",
"see",
"if",
"the",
"supplied",
"record",
"would",
"cause",
"the",
"file",
"to",
"exceed",
"the",
"size",
"limit",
"we",
"have",
"."
] |
65fcbf8cf388a708c9c36def03633ec62056d3f5
|
https://github.com/hhkbp2/go-logging/blob/65fcbf8cf388a708c9c36def03633ec62056d3f5/handler_rotating_file.go#L190-L205
|
17,871 |
hhkbp2/go-logging
|
handler_rotating_file.go
|
RotateFile
|
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
|
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
}
|
[
"func",
"(",
"self",
"*",
"RotatingFileHandler",
")",
"RotateFile",
"(",
"sourceFile",
",",
"destFile",
"string",
")",
"error",
"{",
"if",
"FileExists",
"(",
"sourceFile",
")",
"{",
"if",
"FileExists",
"(",
"destFile",
")",
"{",
"if",
"err",
":=",
"os",
".",
"Remove",
"(",
"destFile",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"err",
":=",
"os",
".",
"Rename",
"(",
"sourceFile",
",",
"destFile",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// Rotate source file to destination file if source file exists.
|
[
"Rotate",
"source",
"file",
"to",
"destination",
"file",
"if",
"source",
"file",
"exists",
"."
] |
65fcbf8cf388a708c9c36def03633ec62056d3f5
|
https://github.com/hhkbp2/go-logging/blob/65fcbf8cf388a708c9c36def03633ec62056d3f5/handler_rotating_file.go#L208-L220
|
17,872 |
hhkbp2/go-logging
|
handler_rotating_file.go
|
DoRollover
|
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
|
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
}
|
[
"func",
"(",
"self",
"*",
"RotatingFileHandler",
")",
"DoRollover",
"(",
")",
"(",
"err",
"error",
")",
"{",
"self",
".",
"FileHandler",
".",
"Close",
"(",
")",
"\n",
"defer",
"func",
"(",
")",
"{",
"if",
"e",
":=",
"self",
".",
"FileHandler",
".",
"Open",
"(",
")",
";",
"e",
"!=",
"nil",
"{",
"if",
"e",
"==",
"nil",
"{",
"err",
"=",
"e",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"(",
")",
"\n",
"if",
"self",
".",
"backupCount",
">",
"0",
"{",
"filepath",
":=",
"self",
".",
"GetFilePath",
"(",
")",
"\n",
"for",
"i",
":=",
"self",
".",
"backupCount",
"-",
"1",
";",
"i",
">",
"0",
";",
"i",
"--",
"{",
"sourceFile",
":=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"filepath",
",",
"i",
")",
"\n",
"destFile",
":=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"filepath",
",",
"i",
"+",
"1",
")",
"\n",
"if",
"err",
":=",
"self",
".",
"RotateFile",
"(",
"sourceFile",
",",
"destFile",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n",
"destFile",
":=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"filepath",
",",
"1",
")",
"\n",
"if",
"err",
":=",
"self",
".",
"RotateFile",
"(",
"filepath",
",",
"destFile",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// Do a rollover, as described above.
|
[
"Do",
"a",
"rollover",
"as",
"described",
"above",
"."
] |
65fcbf8cf388a708c9c36def03633ec62056d3f5
|
https://github.com/hhkbp2/go-logging/blob/65fcbf8cf388a708c9c36def03633ec62056d3f5/handler_rotating_file.go#L223-L247
|
17,873 |
hhkbp2/go-logging
|
handler_socket.go
|
NewSocketHandler
|
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
|
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
}
|
[
"func",
"NewSocketHandler",
"(",
"host",
"string",
",",
"port",
"uint16",
")",
"*",
"SocketHandler",
"{",
"retry",
":=",
"NewErrorRetry",
"(",
")",
".",
"Delay",
"(",
"SocketDefaultDelay",
")",
".",
"Deadline",
"(",
"SocketDefaultMaxDeadline",
")",
"\n",
"object",
":=",
"&",
"SocketHandler",
"{",
"BaseHandler",
":",
"NewBaseHandler",
"(",
"\"",
"\"",
",",
"LevelNotset",
")",
",",
"host",
":",
"host",
",",
"port",
":",
"port",
",",
"closeOnError",
":",
"true",
",",
"retry",
":",
"retry",
",",
"}",
"\n",
"object",
".",
"makeConnFunc",
"=",
"object",
".",
"makeTCPSocket",
"\n",
"object",
".",
"sendFunc",
"=",
"object",
".",
"sendTCP",
"\n",
"Closer",
".",
"AddHandler",
"(",
"object",
")",
"\n",
"return",
"object",
"\n",
"}"
] |
// Initializes the handler with a specific host address and port.
// The attribute 'closeOnError' is set to true by default, which means that
// if a socket error occurs, the socket is silently closed and then reopen
// on the next loggging call.
|
[
"Initializes",
"the",
"handler",
"with",
"a",
"specific",
"host",
"address",
"and",
"port",
".",
"The",
"attribute",
"closeOnError",
"is",
"set",
"to",
"true",
"by",
"default",
"which",
"means",
"that",
"if",
"a",
"socket",
"error",
"occurs",
"the",
"socket",
"is",
"silently",
"closed",
"and",
"then",
"reopen",
"on",
"the",
"next",
"loggging",
"call",
"."
] |
65fcbf8cf388a708c9c36def03633ec62056d3f5
|
https://github.com/hhkbp2/go-logging/blob/65fcbf8cf388a708c9c36def03633ec62056d3f5/handler_socket.go#L52-L67
|
17,874 |
hhkbp2/go-logging
|
handler_socket.go
|
Marshal
|
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
|
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
}
|
[
"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",
",",
"}",
"\n",
"var",
"buf",
"bytes",
".",
"Buffer",
"\n",
"encoder",
":=",
"gob",
".",
"NewEncoder",
"(",
"&",
"buf",
")",
"\n",
"err",
":=",
"encoder",
".",
"Encode",
"(",
"r",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"buf",
".",
"Bytes",
"(",
")",
",",
"nil",
"\n",
"}"
] |
// Marshals the record in gob binary format and returns it ready for
// transmission across socket.
|
[
"Marshals",
"the",
"record",
"in",
"gob",
"binary",
"format",
"and",
"returns",
"it",
"ready",
"for",
"transmission",
"across",
"socket",
"."
] |
65fcbf8cf388a708c9c36def03633ec62056d3f5
|
https://github.com/hhkbp2/go-logging/blob/65fcbf8cf388a708c9c36def03633ec62056d3f5/handler_socket.go#L71-L92
|
17,875 |
hhkbp2/go-logging
|
handler_socket.go
|
makeSocket
|
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
|
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
}
|
[
"func",
"(",
"self",
"*",
"SocketHandler",
")",
"makeSocket",
"(",
"network",
"string",
")",
"error",
"{",
"address",
":=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"self",
".",
"host",
",",
"self",
".",
"port",
")",
"\n",
"conn",
",",
"err",
":=",
"net",
".",
"DialTimeout",
"(",
"network",
",",
"address",
",",
"SocketDefaultTimeout",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"self",
".",
"conn",
"=",
"conn",
"\n",
"return",
"nil",
"\n",
"}"
] |
// A factory method which allows succlasses to define the precise type of
// socket they want.
|
[
"A",
"factory",
"method",
"which",
"allows",
"succlasses",
"to",
"define",
"the",
"precise",
"type",
"of",
"socket",
"they",
"want",
"."
] |
65fcbf8cf388a708c9c36def03633ec62056d3f5
|
https://github.com/hhkbp2/go-logging/blob/65fcbf8cf388a708c9c36def03633ec62056d3f5/handler_socket.go#L96-L104
|
17,876 |
hhkbp2/go-logging
|
handler_socket.go
|
sendTCP
|
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
|
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
}
|
[
"func",
"(",
"self",
"*",
"SocketHandler",
")",
"sendTCP",
"(",
"bin",
"[",
"]",
"byte",
")",
"error",
"{",
"if",
"self",
".",
"conn",
"==",
"nil",
"{",
"err",
":=",
"self",
".",
"createSocket",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n",
"sentSoFar",
",",
"left",
":=",
"0",
",",
"len",
"(",
"bin",
")",
"\n",
"for",
"left",
">",
"0",
"{",
"sent",
",",
"err",
":=",
"self",
".",
"conn",
".",
"Write",
"(",
"bin",
"[",
"sentSoFar",
":",
"]",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"sentSoFar",
"+=",
"sent",
"\n",
"left",
"-=",
"sent",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// Send a marshaled binary to the tcp socket.
|
[
"Send",
"a",
"marshaled",
"binary",
"to",
"the",
"tcp",
"socket",
"."
] |
65fcbf8cf388a708c9c36def03633ec62056d3f5
|
https://github.com/hhkbp2/go-logging/blob/65fcbf8cf388a708c9c36def03633ec62056d3f5/handler_socket.go#L120-L137
|
17,877 |
hhkbp2/go-logging
|
handler_socket.go
|
sendUDP
|
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
|
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
}
|
[
"func",
"(",
"self",
"*",
"SocketHandler",
")",
"sendUDP",
"(",
"bin",
"[",
"]",
"byte",
")",
"error",
"{",
"if",
"self",
".",
"conn",
"==",
"nil",
"{",
"err",
":=",
"self",
".",
"createSocket",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n",
"_",
",",
"err",
":=",
"self",
".",
"conn",
".",
"Write",
"(",
"bin",
")",
"\n",
"return",
"err",
"\n",
"}"
] |
// Send a marshaled binary to the udp socket.
|
[
"Send",
"a",
"marshaled",
"binary",
"to",
"the",
"udp",
"socket",
"."
] |
65fcbf8cf388a708c9c36def03633ec62056d3f5
|
https://github.com/hhkbp2/go-logging/blob/65fcbf8cf388a708c9c36def03633ec62056d3f5/handler_socket.go#L140-L149
|
17,878 |
hhkbp2/go-logging
|
handler_socket.go
|
Emit
|
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
|
func (self *SocketHandler) Emit(record *LogRecord) error {
self.Format(record)
bin, err := self.Marshal(record)
if err != nil {
return err
}
return self.sendFunc(bin)
}
|
[
"func",
"(",
"self",
"*",
"SocketHandler",
")",
"Emit",
"(",
"record",
"*",
"LogRecord",
")",
"error",
"{",
"self",
".",
"Format",
"(",
"record",
")",
"\n",
"bin",
",",
"err",
":=",
"self",
".",
"Marshal",
"(",
"record",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"return",
"self",
".",
"sendFunc",
"(",
"bin",
")",
"\n",
"}"
] |
// Emit a record.
// Marshals the record and writes it to the socket in binary format.
// If there is an error with the socket, silently drop the packet.
// If there was a problem with the socket, re-establishes the socket.
|
[
"Emit",
"a",
"record",
".",
"Marshals",
"the",
"record",
"and",
"writes",
"it",
"to",
"the",
"socket",
"in",
"binary",
"format",
".",
"If",
"there",
"is",
"an",
"error",
"with",
"the",
"socket",
"silently",
"drop",
"the",
"packet",
".",
"If",
"there",
"was",
"a",
"problem",
"with",
"the",
"socket",
"re",
"-",
"establishes",
"the",
"socket",
"."
] |
65fcbf8cf388a708c9c36def03633ec62056d3f5
|
https://github.com/hhkbp2/go-logging/blob/65fcbf8cf388a708c9c36def03633ec62056d3f5/handler_socket.go#L155-L162
|
17,879 |
hhkbp2/go-logging
|
handler_socket.go
|
HandleError
|
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
|
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)
}
}
|
[
"func",
"(",
"self",
"*",
"SocketHandler",
")",
"HandleError",
"(",
"record",
"*",
"LogRecord",
",",
"err",
"error",
")",
"{",
"if",
"self",
".",
"closeOnError",
"&&",
"(",
"self",
".",
"conn",
"!=",
"nil",
")",
"{",
"self",
".",
"conn",
".",
"Close",
"(",
")",
"\n",
"self",
".",
"conn",
"=",
"nil",
"\n",
"}",
"else",
"{",
"self",
".",
"BaseHandler",
".",
"HandleError",
"(",
"record",
",",
"err",
")",
"\n",
"}",
"\n",
"}"
] |
// Handles an error during logging.
// An error has occurred during logging. Most likely cause connection lost.
// Close the socket so that we can retry on the next event.
|
[
"Handles",
"an",
"error",
"during",
"logging",
".",
"An",
"error",
"has",
"occurred",
"during",
"logging",
".",
"Most",
"likely",
"cause",
"connection",
"lost",
".",
"Close",
"the",
"socket",
"so",
"that",
"we",
"can",
"retry",
"on",
"the",
"next",
"event",
"."
] |
65fcbf8cf388a708c9c36def03633ec62056d3f5
|
https://github.com/hhkbp2/go-logging/blob/65fcbf8cf388a708c9c36def03633ec62056d3f5/handler_socket.go#L171-L178
|
17,880 |
hhkbp2/go-logging
|
handler_socket.go
|
Close
|
func (self *SocketHandler) Close() {
self.Lock()
defer self.Unlock()
if self.conn != nil {
self.conn.Close()
self.conn = nil
}
self.BaseHandler.Close()
}
|
go
|
func (self *SocketHandler) Close() {
self.Lock()
defer self.Unlock()
if self.conn != nil {
self.conn.Close()
self.conn = nil
}
self.BaseHandler.Close()
}
|
[
"func",
"(",
"self",
"*",
"SocketHandler",
")",
"Close",
"(",
")",
"{",
"self",
".",
"Lock",
"(",
")",
"\n",
"defer",
"self",
".",
"Unlock",
"(",
")",
"\n",
"if",
"self",
".",
"conn",
"!=",
"nil",
"{",
"self",
".",
"conn",
".",
"Close",
"(",
")",
"\n",
"self",
".",
"conn",
"=",
"nil",
"\n",
"}",
"\n",
"self",
".",
"BaseHandler",
".",
"Close",
"(",
")",
"\n",
"}"
] |
// Close the socket.
|
[
"Close",
"the",
"socket",
"."
] |
65fcbf8cf388a708c9c36def03633ec62056d3f5
|
https://github.com/hhkbp2/go-logging/blob/65fcbf8cf388a708c9c36def03633ec62056d3f5/handler_socket.go#L181-L189
|
17,881 |
hhkbp2/go-logging
|
filter.go
|
Filter
|
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
|
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] == '.')
}
|
[
"func",
"(",
"self",
"*",
"NameFilter",
")",
"Filter",
"(",
"record",
"*",
"LogRecord",
")",
"bool",
"{",
"length",
":=",
"len",
"(",
"self",
".",
"name",
")",
"\n",
"if",
"length",
"==",
"0",
"{",
"return",
"true",
"\n",
"}",
"else",
"if",
"self",
".",
"name",
"==",
"record",
".",
"Name",
"{",
"return",
"true",
"\n",
"}",
"else",
"if",
"!",
"strings",
".",
"HasPrefix",
"(",
"record",
".",
"Name",
",",
"self",
".",
"name",
")",
"{",
"return",
"false",
"\n",
"}",
"\n",
"return",
"(",
"record",
".",
"Name",
"[",
"length",
"]",
"==",
"'.'",
")",
"\n",
"}"
] |
// Determine if the specified record is to be logged.
// Is the specified record to be logged? Returns false for no, true for yes.
// If deemed appropriate, the record may be modified in-place.
|
[
"Determine",
"if",
"the",
"specified",
"record",
"is",
"to",
"be",
"logged",
".",
"Is",
"the",
"specified",
"record",
"to",
"be",
"logged?",
"Returns",
"false",
"for",
"no",
"true",
"for",
"yes",
".",
"If",
"deemed",
"appropriate",
"the",
"record",
"may",
"be",
"modified",
"in",
"-",
"place",
"."
] |
65fcbf8cf388a708c9c36def03633ec62056d3f5
|
https://github.com/hhkbp2/go-logging/blob/65fcbf8cf388a708c9c36def03633ec62056d3f5/filter.go#L35-L45
|
17,882 |
hhkbp2/go-logging
|
filter.go
|
AddFilter
|
func (self *StandardFilterer) AddFilter(filter Filter) {
if !self.filters.SetContains(filter) {
self.filters.SetAdd(filter)
}
}
|
go
|
func (self *StandardFilterer) AddFilter(filter Filter) {
if !self.filters.SetContains(filter) {
self.filters.SetAdd(filter)
}
}
|
[
"func",
"(",
"self",
"*",
"StandardFilterer",
")",
"AddFilter",
"(",
"filter",
"Filter",
")",
"{",
"if",
"!",
"self",
".",
"filters",
".",
"SetContains",
"(",
"filter",
")",
"{",
"self",
".",
"filters",
".",
"SetAdd",
"(",
"filter",
")",
"\n",
"}",
"\n",
"}"
] |
// Add the specified filter.
|
[
"Add",
"the",
"specified",
"filter",
"."
] |
65fcbf8cf388a708c9c36def03633ec62056d3f5
|
https://github.com/hhkbp2/go-logging/blob/65fcbf8cf388a708c9c36def03633ec62056d3f5/filter.go#L68-L72
|
17,883 |
hhkbp2/go-logging
|
filter.go
|
RemoveFilter
|
func (self *StandardFilterer) RemoveFilter(filter Filter) {
if self.filters.SetContains(filter) {
self.filters.SetRemove(filter)
}
}
|
go
|
func (self *StandardFilterer) RemoveFilter(filter Filter) {
if self.filters.SetContains(filter) {
self.filters.SetRemove(filter)
}
}
|
[
"func",
"(",
"self",
"*",
"StandardFilterer",
")",
"RemoveFilter",
"(",
"filter",
"Filter",
")",
"{",
"if",
"self",
".",
"filters",
".",
"SetContains",
"(",
"filter",
")",
"{",
"self",
".",
"filters",
".",
"SetRemove",
"(",
"filter",
")",
"\n",
"}",
"\n",
"}"
] |
// Remove the specified filter.
|
[
"Remove",
"the",
"specified",
"filter",
"."
] |
65fcbf8cf388a708c9c36def03633ec62056d3f5
|
https://github.com/hhkbp2/go-logging/blob/65fcbf8cf388a708c9c36def03633ec62056d3f5/filter.go#L75-L79
|
17,884 |
hhkbp2/go-logging
|
init.go
|
GetLogger
|
func GetLogger(name string) Logger {
if len(name) > 0 {
return manager.GetLogger(name)
} else {
return root
}
}
|
go
|
func GetLogger(name string) Logger {
if len(name) > 0 {
return manager.GetLogger(name)
} else {
return root
}
}
|
[
"func",
"GetLogger",
"(",
"name",
"string",
")",
"Logger",
"{",
"if",
"len",
"(",
"name",
")",
">",
"0",
"{",
"return",
"manager",
".",
"GetLogger",
"(",
"name",
")",
"\n",
"}",
"else",
"{",
"return",
"root",
"\n",
"}",
"\n",
"}"
] |
// Return a logger with the specified name, creating it if necessary.
// If empty name is specified, return the root logger.
|
[
"Return",
"a",
"logger",
"with",
"the",
"specified",
"name",
"creating",
"it",
"if",
"necessary",
".",
"If",
"empty",
"name",
"is",
"specified",
"return",
"the",
"root",
"logger",
"."
] |
65fcbf8cf388a708c9c36def03633ec62056d3f5
|
https://github.com/hhkbp2/go-logging/blob/65fcbf8cf388a708c9c36def03633ec62056d3f5/init.go#L72-L78
|
17,885 |
hhkbp2/go-logging
|
init.go
|
Logf
|
func Logf(level LogLevelType, format string, args ...interface{}) {
root.Logf(level, format, args...)
}
|
go
|
func Logf(level LogLevelType, format string, args ...interface{}) {
root.Logf(level, format, args...)
}
|
[
"func",
"Logf",
"(",
"level",
"LogLevelType",
",",
"format",
"string",
",",
"args",
"...",
"interface",
"{",
"}",
")",
"{",
"root",
".",
"Logf",
"(",
"level",
",",
"format",
",",
"args",
"...",
")",
"\n",
"}"
] |
// Log a message with specified severity level on the root logger.
|
[
"Log",
"a",
"message",
"with",
"specified",
"severity",
"level",
"on",
"the",
"root",
"logger",
"."
] |
65fcbf8cf388a708c9c36def03633ec62056d3f5
|
https://github.com/hhkbp2/go-logging/blob/65fcbf8cf388a708c9c36def03633ec62056d3f5/init.go#L111-L113
|
17,886 |
hhkbp2/go-logging
|
handler_file.go
|
NewFileHandler
|
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
|
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
}
|
[
"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",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"handler",
":=",
"NewStreamHandler",
"(",
"filepath",
",",
"LevelNotset",
",",
"nil",
")",
"\n",
"object",
":=",
"&",
"FileHandler",
"{",
"StreamHandler",
":",
"handler",
",",
"filepath",
":",
"filepath",
",",
"mode",
":",
"mode",
",",
"bufferSize",
":",
"bufferSize",
",",
"}",
"\n",
"if",
"err",
"=",
"object",
".",
"Open",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"Closer",
".",
"RemoveHandler",
"(",
"object",
".",
"StreamHandler",
")",
"\n",
"Closer",
".",
"AddHandler",
"(",
"object",
")",
"\n",
"return",
"object",
",",
"nil",
"\n",
"}"
] |
// Open the specified file and use it as the stream for logging.
|
[
"Open",
"the",
"specified",
"file",
"and",
"use",
"it",
"as",
"the",
"stream",
"for",
"logging",
"."
] |
65fcbf8cf388a708c9c36def03633ec62056d3f5
|
https://github.com/hhkbp2/go-logging/blob/65fcbf8cf388a708c9c36def03633ec62056d3f5/handler_file.go#L126-L146
|
17,887 |
hhkbp2/go-logging
|
config.go
|
ApplyConfigFile
|
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
|
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))
}
}
|
[
"func",
"ApplyConfigFile",
"(",
"file",
"string",
")",
"error",
"{",
"ext",
":=",
"filepath",
".",
"Ext",
"(",
"file",
")",
"\n",
"switch",
"ext",
"{",
"case",
"\"",
"\"",
":",
"return",
"ApplyJsonConfigFile",
"(",
"file",
")",
"\n",
"case",
"\"",
"\"",
":",
"fallthrough",
"\n",
"case",
"\"",
"\"",
":",
"return",
"ApplyYAMLConfigFile",
"(",
"file",
")",
"\n",
"default",
":",
"return",
"errors",
".",
"New",
"(",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"file",
")",
")",
"\n",
"}",
"\n",
"}"
] |
// Apply all configuration in specified file.
|
[
"Apply",
"all",
"configuration",
"in",
"specified",
"file",
"."
] |
65fcbf8cf388a708c9c36def03633ec62056d3f5
|
https://github.com/hhkbp2/go-logging/blob/65fcbf8cf388a708c9c36def03633ec62056d3f5/config.go#L70-L83
|
17,888 |
hhkbp2/go-logging
|
config.go
|
ApplyJsonConfigFile
|
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
|
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)
}
|
[
"func",
"ApplyJsonConfigFile",
"(",
"file",
"string",
")",
"error",
"{",
"bin",
",",
"err",
":=",
"ioutil",
".",
"ReadFile",
"(",
"file",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"decoder",
":=",
"json",
".",
"NewDecoder",
"(",
"bytes",
".",
"NewBuffer",
"(",
"bin",
")",
")",
"\n",
"decoder",
".",
"UseNumber",
"(",
")",
"\n",
"var",
"conf",
"Conf",
"\n",
"if",
"err",
"=",
"decoder",
".",
"Decode",
"(",
"&",
"conf",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"return",
"DictConfig",
"(",
"&",
"conf",
")",
"\n",
"}"
] |
// Apply all configuration in specified json file.
|
[
"Apply",
"all",
"configuration",
"in",
"specified",
"json",
"file",
"."
] |
65fcbf8cf388a708c9c36def03633ec62056d3f5
|
https://github.com/hhkbp2/go-logging/blob/65fcbf8cf388a708c9c36def03633ec62056d3f5/config.go#L86-L98
|
17,889 |
hhkbp2/go-logging
|
config.go
|
ApplyYAMLConfigFile
|
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
|
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)
}
|
[
"func",
"ApplyYAMLConfigFile",
"(",
"file",
"string",
")",
"error",
"{",
"bin",
",",
"err",
":=",
"ioutil",
".",
"ReadFile",
"(",
"file",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"var",
"conf",
"Conf",
"\n",
"if",
"err",
"=",
"yaml",
".",
"Unmarshal",
"(",
"bin",
",",
"&",
"conf",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"return",
"DictConfig",
"(",
"&",
"conf",
")",
"\n",
"}"
] |
// Apply all configuration in specified yaml file.
|
[
"Apply",
"all",
"configuration",
"in",
"specified",
"yaml",
"file",
"."
] |
65fcbf8cf388a708c9c36def03633ec62056d3f5
|
https://github.com/hhkbp2/go-logging/blob/65fcbf8cf388a708c9c36def03633ec62056d3f5/config.go#L101-L111
|
17,890 |
hhkbp2/go-logging
|
handler.go
|
NewBaseHandler
|
func NewBaseHandler(name string, level LogLevelType) *BaseHandler {
return &BaseHandler{
StandardFilterer: NewStandardFilterer(),
name: name,
level: level,
formatter: nil,
}
}
|
go
|
func NewBaseHandler(name string, level LogLevelType) *BaseHandler {
return &BaseHandler{
StandardFilterer: NewStandardFilterer(),
name: name,
level: level,
formatter: nil,
}
}
|
[
"func",
"NewBaseHandler",
"(",
"name",
"string",
",",
"level",
"LogLevelType",
")",
"*",
"BaseHandler",
"{",
"return",
"&",
"BaseHandler",
"{",
"StandardFilterer",
":",
"NewStandardFilterer",
"(",
")",
",",
"name",
":",
"name",
",",
"level",
":",
"level",
",",
"formatter",
":",
"nil",
",",
"}",
"\n",
"}"
] |
// Initialize the instance - basically setting the formatter to nil and the
// filterer without filter.
|
[
"Initialize",
"the",
"instance",
"-",
"basically",
"setting",
"the",
"formatter",
"to",
"nil",
"and",
"the",
"filterer",
"without",
"filter",
"."
] |
65fcbf8cf388a708c9c36def03633ec62056d3f5
|
https://github.com/hhkbp2/go-logging/blob/65fcbf8cf388a708c9c36def03633ec62056d3f5/handler.go#L58-L65
|
17,891 |
hhkbp2/go-logging
|
handler.go
|
Format
|
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
|
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)
}
|
[
"func",
"(",
"self",
"*",
"BaseHandler",
")",
"Format",
"(",
"record",
"*",
"LogRecord",
")",
"string",
"{",
"self",
".",
"formatterLock",
".",
"RLock",
"(",
")",
"\n",
"defer",
"self",
".",
"formatterLock",
".",
"RUnlock",
"(",
")",
"\n",
"var",
"formatter",
"Formatter",
"\n",
"if",
"self",
".",
"formatter",
"!=",
"nil",
"{",
"formatter",
"=",
"self",
".",
"formatter",
"\n",
"}",
"else",
"{",
"formatter",
"=",
"defaultFormatter",
"\n",
"}",
"\n",
"return",
"formatter",
".",
"Format",
"(",
"record",
")",
"\n",
"}"
] |
// Format the specified record.
// If a formatter is set, use it. Otherwise, use the default formatter
// for the module.
|
[
"Format",
"the",
"specified",
"record",
".",
"If",
"a",
"formatter",
"is",
"set",
"use",
"it",
".",
"Otherwise",
"use",
"the",
"default",
"formatter",
"for",
"the",
"module",
"."
] |
65fcbf8cf388a708c9c36def03633ec62056d3f5
|
https://github.com/hhkbp2/go-logging/blob/65fcbf8cf388a708c9c36def03633ec62056d3f5/handler.go#L115-L125
|
17,892 |
hhkbp2/go-logging
|
level.go
|
AddLevel
|
func AddLevel(level LogLevelType, levelName string) {
levelLock.Lock()
defer levelLock.Unlock()
levelToNames[level] = levelName
nameToLevels[levelName] = level
}
|
go
|
func AddLevel(level LogLevelType, levelName string) {
levelLock.Lock()
defer levelLock.Unlock()
levelToNames[level] = levelName
nameToLevels[levelName] = level
}
|
[
"func",
"AddLevel",
"(",
"level",
"LogLevelType",
",",
"levelName",
"string",
")",
"{",
"levelLock",
".",
"Lock",
"(",
")",
"\n",
"defer",
"levelLock",
".",
"Unlock",
"(",
")",
"\n",
"levelToNames",
"[",
"level",
"]",
"=",
"levelName",
"\n",
"nameToLevels",
"[",
"levelName",
"]",
"=",
"level",
"\n",
"}"
] |
// Associate levelName with level.
// This is used when converting levels to test during message formatting.
|
[
"Associate",
"levelName",
"with",
"level",
".",
"This",
"is",
"used",
"when",
"converting",
"levels",
"to",
"test",
"during",
"message",
"formatting",
"."
] |
65fcbf8cf388a708c9c36def03633ec62056d3f5
|
https://github.com/hhkbp2/go-logging/blob/65fcbf8cf388a708c9c36def03633ec62056d3f5/level.go#L80-L85
|
17,893 |
hhkbp2/go-logging
|
logger.go
|
NewPlaceHolder
|
func NewPlaceHolder(logger Logger) *PlaceHolder {
object := &PlaceHolder{
Loggers: NewListSet(),
}
object.Append(logger)
return object
}
|
go
|
func NewPlaceHolder(logger Logger) *PlaceHolder {
object := &PlaceHolder{
Loggers: NewListSet(),
}
object.Append(logger)
return object
}
|
[
"func",
"NewPlaceHolder",
"(",
"logger",
"Logger",
")",
"*",
"PlaceHolder",
"{",
"object",
":=",
"&",
"PlaceHolder",
"{",
"Loggers",
":",
"NewListSet",
"(",
")",
",",
"}",
"\n",
"object",
".",
"Append",
"(",
"logger",
")",
"\n",
"return",
"object",
"\n",
"}"
] |
// Initialize a PlaceHolder with the specified logger being a child of
// this PlaceHolder.
|
[
"Initialize",
"a",
"PlaceHolder",
"with",
"the",
"specified",
"logger",
"being",
"a",
"child",
"of",
"this",
"PlaceHolder",
"."
] |
65fcbf8cf388a708c9c36def03633ec62056d3f5
|
https://github.com/hhkbp2/go-logging/blob/65fcbf8cf388a708c9c36def03633ec62056d3f5/logger.go#L43-L49
|
17,894 |
hhkbp2/go-logging
|
logger.go
|
Append
|
func (self *PlaceHolder) Append(logger Logger) {
if !self.Loggers.SetContains(logger) {
self.Loggers.SetAdd(logger)
}
}
|
go
|
func (self *PlaceHolder) Append(logger Logger) {
if !self.Loggers.SetContains(logger) {
self.Loggers.SetAdd(logger)
}
}
|
[
"func",
"(",
"self",
"*",
"PlaceHolder",
")",
"Append",
"(",
"logger",
"Logger",
")",
"{",
"if",
"!",
"self",
".",
"Loggers",
".",
"SetContains",
"(",
"logger",
")",
"{",
"self",
".",
"Loggers",
".",
"SetAdd",
"(",
"logger",
")",
"\n",
"}",
"\n",
"}"
] |
// Add the specified logger as a child of this PlaceHolder.
|
[
"Add",
"the",
"specified",
"logger",
"as",
"a",
"child",
"of",
"this",
"PlaceHolder",
"."
] |
65fcbf8cf388a708c9c36def03633ec62056d3f5
|
https://github.com/hhkbp2/go-logging/blob/65fcbf8cf388a708c9c36def03633ec62056d3f5/logger.go#L56-L60
|
17,895 |
hhkbp2/go-logging
|
logger.go
|
findCaller
|
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
|
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,
}
}
}
}
|
[
"func",
"findCaller",
"(",
")",
"*",
"CallerInfo",
"{",
"for",
"i",
":=",
"3",
";",
";",
"i",
"++",
"{",
"pc",
",",
"filepath",
",",
"line",
",",
"ok",
":=",
"runtime",
".",
"Caller",
"(",
"i",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"UnknownCallerInfo",
"\n",
"}",
"\n",
"parts",
":=",
"strings",
".",
"Split",
"(",
"filepath",
",",
"\"",
"\"",
")",
"\n",
"dir",
":=",
"parts",
"[",
"len",
"(",
"parts",
")",
"-",
"2",
"]",
"\n",
"file",
":=",
"parts",
"[",
"len",
"(",
"parts",
")",
"-",
"1",
"]",
"\n",
"if",
"(",
"dir",
"!=",
"thisPackageName",
")",
"||",
"(",
"file",
"!=",
"thisFileName",
")",
"{",
"funcName",
":=",
"runtime",
".",
"FuncForPC",
"(",
"pc",
")",
".",
"Name",
"(",
")",
"\n",
"return",
"&",
"CallerInfo",
"{",
"PathName",
":",
"filepath",
",",
"FileName",
":",
"file",
",",
"LineNo",
":",
"uint32",
"(",
"line",
")",
",",
"FuncName",
":",
"funcName",
",",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] |
// Find the stack frame of the caller so that we can note the source file name,
// line number and function name.
|
[
"Find",
"the",
"stack",
"frame",
"of",
"the",
"caller",
"so",
"that",
"we",
"can",
"note",
"the",
"source",
"file",
"name",
"line",
"number",
"and",
"function",
"name",
"."
] |
65fcbf8cf388a708c9c36def03633ec62056d3f5
|
https://github.com/hhkbp2/go-logging/blob/65fcbf8cf388a708c9c36def03633ec62056d3f5/logger.go#L165-L184
|
17,896 |
hhkbp2/go-logging
|
logger.go
|
NewStandardLogger
|
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
|
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
}
|
[
"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",
",",
"}",
"\n",
"return",
"object",
"\n",
"}"
] |
// Initialize a standard logger instance with name and logging level.
|
[
"Initialize",
"a",
"standard",
"logger",
"instance",
"with",
"name",
"and",
"logging",
"level",
"."
] |
65fcbf8cf388a708c9c36def03633ec62056d3f5
|
https://github.com/hhkbp2/go-logging/blob/65fcbf8cf388a708c9c36def03633ec62056d3f5/logger.go#L200-L212
|
17,897 |
hhkbp2/go-logging
|
logger.go
|
GetEffectiveLevel
|
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
|
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
}
|
[
"func",
"(",
"self",
"*",
"StandardLogger",
")",
"GetEffectiveLevel",
"(",
")",
"LogLevelType",
"{",
"self",
".",
"lock",
".",
"RLock",
"(",
")",
"\n",
"defer",
"self",
".",
"lock",
".",
"RUnlock",
"(",
")",
"\n",
"var",
"logger",
"Logger",
"=",
"self",
"\n",
"for",
"logger",
"!=",
"nil",
"{",
"level",
":=",
"logger",
".",
"GetLevel",
"(",
")",
"\n",
"if",
"level",
"!=",
"LevelNotset",
"{",
"return",
"level",
"\n",
"}",
"\n",
"logger",
"=",
"logger",
".",
"GetParent",
"(",
")",
"\n",
"}",
"\n",
"return",
"LevelNotset",
"\n",
"}"
] |
// Get the effective level for this logger.
// Loop through this logger and its parents in the logger hierarchy,
// looking for a non-zero logging level. Return the first one found.
|
[
"Get",
"the",
"effective",
"level",
"for",
"this",
"logger",
".",
"Loop",
"through",
"this",
"logger",
"and",
"its",
"parents",
"in",
"the",
"logger",
"hierarchy",
"looking",
"for",
"a",
"non",
"-",
"zero",
"logging",
"level",
".",
"Return",
"the",
"first",
"one",
"found",
"."
] |
65fcbf8cf388a708c9c36def03633ec62056d3f5
|
https://github.com/hhkbp2/go-logging/blob/65fcbf8cf388a708c9c36def03633ec62056d3f5/logger.go#L266-L278
|
17,898 |
hhkbp2/go-logging
|
logger.go
|
traverseHandlers
|
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
|
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()
}
}
}
|
[
"func",
"(",
"self",
"*",
"StandardLogger",
")",
"traverseHandlers",
"(",
"record",
"*",
"LogRecord",
")",
"{",
"var",
"call",
"Logger",
"=",
"self",
"\n",
"for",
"call",
"!=",
"nil",
"{",
"call",
".",
"CallHandlers",
"(",
"record",
")",
"\n",
"if",
"!",
"call",
".",
"GetPropagate",
"(",
")",
"{",
"call",
"=",
"nil",
"\n",
"}",
"else",
"{",
"call",
"=",
"call",
".",
"GetParent",
"(",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] |
// Pass a record to all relevant handlers.
// Loop through all handlers for this logger and its parents in the logger
// hierarchy. Stop searching up the hierarchy whenever a logger with the
// "propagate" attribute set to false is found - that will be the last
// logger whose handlers are called.
|
[
"Pass",
"a",
"record",
"to",
"all",
"relevant",
"handlers",
".",
"Loop",
"through",
"all",
"handlers",
"for",
"this",
"logger",
"and",
"its",
"parents",
"in",
"the",
"logger",
"hierarchy",
".",
"Stop",
"searching",
"up",
"the",
"hierarchy",
"whenever",
"a",
"logger",
"with",
"the",
"propagate",
"attribute",
"set",
"to",
"false",
"is",
"found",
"-",
"that",
"will",
"be",
"the",
"last",
"logger",
"whose",
"handlers",
"are",
"called",
"."
] |
65fcbf8cf388a708c9c36def03633ec62056d3f5
|
https://github.com/hhkbp2/go-logging/blob/65fcbf8cf388a708c9c36def03633ec62056d3f5/logger.go#L430-L440
|
17,899 |
hhkbp2/go-logging
|
logger.go
|
NewRootLogger
|
func NewRootLogger(level LogLevelType) *RootLogger {
logger := NewStandardLogger("root", level)
logger.SetPropagate(false)
return &RootLogger{
StandardLogger: logger,
}
}
|
go
|
func NewRootLogger(level LogLevelType) *RootLogger {
logger := NewStandardLogger("root", level)
logger.SetPropagate(false)
return &RootLogger{
StandardLogger: logger,
}
}
|
[
"func",
"NewRootLogger",
"(",
"level",
"LogLevelType",
")",
"*",
"RootLogger",
"{",
"logger",
":=",
"NewStandardLogger",
"(",
"\"",
"\"",
",",
"level",
")",
"\n",
"logger",
".",
"SetPropagate",
"(",
"false",
")",
"\n",
"return",
"&",
"RootLogger",
"{",
"StandardLogger",
":",
"logger",
",",
"}",
"\n",
"}"
] |
// Initialize the root logger with the name "root".
|
[
"Initialize",
"the",
"root",
"logger",
"with",
"the",
"name",
"root",
"."
] |
65fcbf8cf388a708c9c36def03633ec62056d3f5
|
https://github.com/hhkbp2/go-logging/blob/65fcbf8cf388a708c9c36def03633ec62056d3f5/logger.go#L526-L532
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.