_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q17800 | FixNameServers | train | func FixNameServers(nservers string) string {
servers := strings.Split(nservers, ",")
for k, v := range servers {
names := strings.Split(strings.TrimSpace(v), " ")
servers[k] = strings.Trim(names[0], ".")
}
return strings.Join(servers, ",")
} | go | {
"resource": ""
} |
q17801 | UnmarshalJSON | train | func (c *CheckResponseType) UnmarshalJSON(b []byte) error {
var raw interface{}
err := json.Unmarshal(b, &raw)
if err != nil {
return err
}
switch v := raw.(type) {
case string:
c.Name = v
case map[string]interface{}:
if len(v) != 1 {
return fmt.Errorf("Check detailed response `check.type` contains mo... | go | {
"resource": ""
} |
q17802 | Error | train | func (r *PingdomError) Error() string {
return fmt.Sprintf("%d %v: %v", r.StatusCode, r.StatusDesc, r.Message)
} | go | {
"resource": ""
} |
q17803 | List | train | func (cs *PublicReportService) List() ([]PublicReportResponse, error) {
req, err := cs.client.NewRequest("GET", "/reports.public", nil)
if err != nil {
return nil, err
}
resp, err := cs.client.client.Do(req)
if err != nil {
return nil, err
}
defer resp.Body.Close()
if err := validateResponse(resp); err !=... | go | {
"resource": ""
} |
q17804 | PublishCheck | train | func (cs *PublicReportService) PublishCheck(id int) (*PingdomResponse, error) {
req, err := cs.client.NewRequest("PUT", "/reports.public/"+strconv.Itoa(id), nil)
if err != nil {
return nil, err
}
t := &PingdomResponse{}
_, err = cs.client.Do(req, t)
if err != nil {
return nil, err
}
return t, err
} | go | {
"resource": ""
} |
q17805 | PutParams | train | func (ck *TeamData) PutParams() map[string]string {
t := map[string]string{
"name": ck.Name,
}
// Ignore if not defined
if ck.UserIds != "" {
t["userids"] = ck.UserIds
}
return t
} | go | {
"resource": ""
} |
q17806 | List | train | func (cs *ProbeService) List(params ...map[string]string) ([]ProbeResponse, error) {
param := map[string]string{}
if len(params) == 1 {
param = params[0]
}
req, err := cs.client.NewRequest("GET", "/probes", param)
if err != nil {
return nil, err
}
resp, err := cs.client.client.Do(req)
if err != nil {
ret... | go | {
"resource": ""
} |
q17807 | ValidContact | train | func (c *Contact) ValidContact() error {
if c.Email == "" && c.Number == "" {
return fmt.Errorf("you must provide either an Email or a Phone Number to create a contact target")
}
if c.Number != "" && c.CountryCode == "" {
return fmt.Errorf("you must provide a Country Code if providing a phone number")
}
if c... | go | {
"resource": ""
} |
q17808 | PostParams | train | func (u *User) PostParams() map[string]string {
m := map[string]string{
"name": u.Username,
}
return m
} | go | {
"resource": ""
} |
q17809 | PostContactParams | train | func (c *Contact) PostContactParams() map[string]string {
m := map[string]string{}
// Ignore if not defined
if c.Email != "" {
m["email"] = c.Email
}
if c.Number != "" {
m["number"] = c.Number
}
if c.CountryCode != "" {
m["countrycode"] = c.CountryCode
}
if c.Severity != "" {
m["severitylevel"] = c... | go | {
"resource": ""
} |
q17810 | PutParams | train | func (u *User) PutParams() map[string]string {
m := map[string]string{
"name": u.Username,
}
if u.Primary != "" {
m["primary"] = u.Primary
}
if u.Paused != "" {
m["paused"] = u.Paused
}
return m
} | go | {
"resource": ""
} |
q17811 | List | train | func (cs *MaintenanceService) List(params ...map[string]string) ([]MaintenanceResponse, error) {
param := map[string]string{}
if len(params) != 0 {
for _, m := range params {
for k, v := range m {
param[k] = v
}
}
}
req, err := cs.client.NewRequest("GET", "/maintenance", param)
if err != nil {
retu... | go | {
"resource": ""
} |
q17812 | Read | train | func (cs *MaintenanceService) Read(id int) (*MaintenanceResponse, error) {
req, err := cs.client.NewRequest("GET", "/maintenance/"+strconv.Itoa(id), nil)
if err != nil {
return nil, err
}
m := &maintenanceDetailsJSONResponse{}
_, err = cs.client.Do(req, m)
if err != nil {
return nil, err
}
return m.Mainte... | go | {
"resource": ""
} |
q17813 | Create | train | func (cs *MaintenanceService) Create(maintenance Maintenance) (*MaintenanceResponse, error) {
if err := maintenance.Valid(); err != nil {
return nil, err
}
req, err := cs.client.NewRequest("POST", "/maintenance", maintenance.PostParams())
if err != nil {
return nil, err
}
m := &maintenanceDetailsJSONRespons... | go | {
"resource": ""
} |
q17814 | Update | train | func (cs *MaintenanceService) Update(id int, maintenance Maintenance) (*PingdomResponse, error) {
if err := maintenance.Valid(); err != nil {
return nil, err
}
req, err := cs.client.NewRequest("PUT", "/maintenance/"+strconv.Itoa(id), maintenance.PutParams())
if err != nil {
return nil, err
}
m := &PingdomRe... | go | {
"resource": ""
} |
q17815 | MultiDelete | train | func (cs *MaintenanceService) MultiDelete(maintenance MaintenanceDelete) (*PingdomResponse, error) {
if err := maintenance.ValidDelete(); err != nil {
return nil, err
}
req, err := cs.client.NewRequest("DELETE", "/maintenance/", maintenance.DeleteParams())
if err != nil {
return nil, err
}
m := &PingdomResp... | go | {
"resource": ""
} |
q17816 | List | train | func (cs *UserService) List() ([]UsersResponse, error) {
req, err := cs.client.NewRequest("GET", "/users", nil)
if err != nil {
return nil, err
}
resp, err := cs.client.client.Do(req)
if err != nil {
return nil, err
}
defer resp.Body.Close()
if err := validateResponse(resp); err != nil {
return nil, er... | go | {
"resource": ""
} |
q17817 | Read | train | func (cs *UserService) Read(userID int) (*UsersResponse, error) {
users, err := cs.List()
if err != nil {
return nil, err
}
for i := range users {
if users[i].Id == userID {
return &users[i], nil
}
}
return nil, fmt.Errorf("UserId: " + strconv.Itoa(userID) + " not found")
} | go | {
"resource": ""
} |
q17818 | Create | train | func (cs *UserService) Create(user UserApi) (*UsersResponse, error) {
if err := user.ValidUser(); err != nil {
return nil, err
}
req, err := cs.client.NewRequest("POST", "/users", user.PostParams())
if err != nil {
return nil, err
}
m := &createUserJSONResponse{}
_, err = cs.client.Do(req, m)
if err != ni... | go | {
"resource": ""
} |
q17819 | CreateContact | train | func (cs *UserService) CreateContact(userID int, contact Contact) (*CreateUserContactResponse, error) {
if err := contact.ValidContact(); err != nil {
return nil, err
}
req, err := cs.client.NewRequest("POST", "/users/"+strconv.Itoa(userID), contact.PostContactParams())
if err != nil {
return nil, err
}
m :... | go | {
"resource": ""
} |
q17820 | Update | train | func (cs *UserService) Update(id int, user UserApi) (*PingdomResponse, error) {
if err := user.ValidUser(); err != nil {
return nil, err
}
req, err := cs.client.NewRequest("PUT", "/users/"+strconv.Itoa(id), user.PutParams())
if err != nil {
return nil, err
}
m := &PingdomResponse{}
_, err = cs.client.Do(re... | go | {
"resource": ""
} |
q17821 | UpdateContact | train | func (cs *UserService) UpdateContact(userID int, contactID int, contact Contact) (*PingdomResponse, error) {
if err := contact.ValidContact(); err != nil {
return nil, err
}
req, err := cs.client.NewRequest("PUT", "/users/"+strconv.Itoa(userID)+"/"+strconv.Itoa(contactID), contact.PutContactParams())
if err != n... | go | {
"resource": ""
} |
q17822 | DeleteContact | train | func (cs *UserService) DeleteContact(userID int, contactID int) (*PingdomResponse, error) {
req, err := cs.client.NewRequest("DELETE", "/users/"+strconv.Itoa(userID)+"/"+strconv.Itoa(contactID), nil)
if err != nil {
return nil, err
}
m := &PingdomResponse{}
_, err = cs.client.Do(req, m)
if err != nil {
retur... | go | {
"resource": ""
} |
q17823 | List | train | func (cs *TeamService) List() ([]TeamResponse, error) {
req, err := cs.client.NewRequest("GET", "/teams", nil)
if err != nil {
return nil, err
}
resp, err := cs.client.client.Do(req)
if err != nil {
return nil, err
}
defer resp.Body.Close()
if err := validateResponse(resp); err != nil {
return nil, err
... | go | {
"resource": ""
} |
q17824 | Read | train | func (cs *TeamService) Read(id int) (*TeamResponse, error) {
req, err := cs.client.NewRequest("GET", "/teams/"+strconv.Itoa(id), nil)
if err != nil {
return nil, err
}
t := &teamDetailsJSONResponse{}
_, err = cs.client.Do(req, t)
if err != nil {
return nil, err
}
return t.Team, err
} | go | {
"resource": ""
} |
q17825 | Create | train | func (cs *TeamService) Create(team Team) (*TeamResponse, error) {
if err := team.Valid(); err != nil {
return nil, err
}
req, err := cs.client.NewRequest("POST", "/teams", team.PostParams())
if err != nil {
return nil, err
}
t := &TeamResponse{}
_, err = cs.client.Do(req, t)
if err != nil {
return nil, ... | go | {
"resource": ""
} |
q17826 | Update | train | func (cs *TeamService) Update(id int, team Team) (*TeamResponse, error) {
req, err := cs.client.NewRequest("PUT", "/teams/"+strconv.Itoa(id), team.PutParams())
if err != nil {
return nil, err
}
t := &TeamResponse{}
_, err = cs.client.Do(req, t)
if err != nil {
return nil, err
}
return t, err
} | go | {
"resource": ""
} |
q17827 | Delete | train | func (cs *TeamService) Delete(id int) (*TeamDeleteResponse, error) {
req, err := cs.client.NewRequest("DELETE", "/teams/"+strconv.Itoa(id), nil)
if err != nil {
return nil, err
}
t := &TeamDeleteResponse{}
_, err = cs.client.Do(req, t)
if err != nil {
return nil, err
}
return t, err
} | go | {
"resource": ""
} |
q17828 | PutParams | train | func (ck *MaintenanceWindow) PutParams() map[string]string {
m := map[string]string{
"description": ck.Description,
"from": strconv.FormatInt(ck.From, 10),
"to": strconv.FormatInt(ck.To, 10),
}
// Ignore if not defined
if ck.RecurrenceType != "" {
m["recurrencetype"] = ck.RecurrenceType
}
... | go | {
"resource": ""
} |
q17829 | Valid | train | func (ck *MaintenanceWindow) Valid() error {
if ck.Description == "" {
return fmt.Errorf("Invalid value for `Description`. Must contain non-empty string")
}
if ck.From == 0 {
return fmt.Errorf("Invalid value for `From`. Must contain time")
}
if ck.To == 0 {
return fmt.Errorf("Invalid value for `To`. Mus... | go | {
"resource": ""
} |
q17830 | DeleteParams | train | func (ck *MaintenanceWindowDelete) DeleteParams() map[string]string {
m := map[string]string{
"maintenanceids": ck.MaintenanceIDs,
}
return m
} | go | {
"resource": ""
} |
q17831 | List | train | func (cs *CheckService) List(params ...map[string]string) ([]CheckResponse, error) {
param := map[string]string{}
if len(params) == 1 {
param = params[0]
}
req, err := cs.client.NewRequest("GET", "/checks", param)
if err != nil {
return nil, err
}
resp, err := cs.client.client.Do(req)
if err != nil {
ret... | go | {
"resource": ""
} |
q17832 | Create | train | func (cs *CheckService) Create(check Check) (*CheckResponse, error) {
if err := check.Valid(); err != nil {
return nil, err
}
req, err := cs.client.NewRequest("POST", "/checks", check.PostParams())
if err != nil {
return nil, err
}
m := &checkDetailsJSONResponse{}
_, err = cs.client.Do(req, m)
if err != n... | go | {
"resource": ""
} |
q17833 | Read | train | func (cs *CheckService) Read(id int) (*CheckResponse, error) {
req, err := cs.client.NewRequest("GET", "/checks/"+strconv.Itoa(id)+"?include_teams=true", nil)
if err != nil {
return nil, err
}
m := &checkDetailsJSONResponse{}
_, err = cs.client.Do(req, m)
if err != nil {
return nil, err
}
m.Check.TeamIds =... | go | {
"resource": ""
} |
q17834 | Update | train | func (cs *CheckService) Update(id int, check Check) (*PingdomResponse, error) {
if err := check.Valid(); err != nil {
return nil, err
}
req, err := cs.client.NewRequest("PUT", "/checks/"+strconv.Itoa(id), check.PutParams())
if err != nil {
return nil, err
}
m := &PingdomResponse{}
_, err = cs.client.Do(req... | go | {
"resource": ""
} |
q17835 | Delete | train | func (cs *CheckService) Delete(id int) (*PingdomResponse, error) {
req, err := cs.client.NewRequest("DELETE", "/checks/"+strconv.Itoa(id), nil)
if err != nil {
return nil, err
}
m := &PingdomResponse{}
_, err = cs.client.Do(req, m)
if err != nil {
return nil, err
}
return m, err
} | go | {
"resource": ""
} |
q17836 | SummaryPerformance | train | func (cs *CheckService) SummaryPerformance(request SummaryPerformanceRequest) (*SummaryPerformanceResponse, error) {
if err := request.Valid(); err != nil {
return nil, err
}
req, err := cs.client.NewRequest("GET", "/summary.performance/"+strconv.Itoa(request.Id), request.GetParams())
if err != nil {
return ni... | go | {
"resource": ""
} |
q17837 | NewClientWithConfig | train | func NewClientWithConfig(config ClientConfig) (*Client, error) {
var baseURL *url.URL
var err error
if config.BaseURL != "" {
baseURL, err = url.Parse(config.BaseURL)
} else {
baseURL, err = url.Parse(defaultBaseURL)
}
if err != nil {
return nil, err
}
c := &Client{
User: config.User,
Passwor... | go | {
"resource": ""
} |
q17838 | NewRequest | train | func (pc *Client) NewRequest(method string, rsc string, params map[string]string) (*http.Request, error) {
baseURL, err := url.Parse(pc.BaseURL.String() + rsc)
if err != nil {
return nil, err
}
if params != nil {
ps := url.Values{}
for k, v := range params {
ps.Set(k, v)
}
baseURL.RawQuery = ps.Encode... | go | {
"resource": ""
} |
q17839 | Do | train | func (pc *Client) Do(req *http.Request, v interface{}) (*http.Response, error) {
resp, err := pc.client.Do(req)
if err != nil {
return nil, err
}
defer resp.Body.Close()
if err := validateResponse(resp); err != nil {
return resp, err
}
err = decodeResponse(resp, v)
return resp, err
} | go | {
"resource": ""
} |
q17840 | validateResponse | train | func validateResponse(r *http.Response) error {
if c := r.StatusCode; 200 <= c && c <= 299 {
return nil
}
bodyBytes, _ := ioutil.ReadAll(r.Body)
bodyString := string(bodyBytes)
m := &errorJSONResponse{}
err := json.Unmarshal([]byte(bodyString), &m)
if err != nil {
return err
}
return m.Error
} | go | {
"resource": ""
} |
q17841 | PutParams | train | func (ck *HttpCheck) PutParams() map[string]string {
m := map[string]string{
"name": ck.Name,
"host": ck.Hostname,
"resolution": strconv.Itoa(ck.Resolution),
"paused": strconv.FormatBool(ck.Paused),
"notifyagainevery": strconv.Itoa(ck.NotifyAgainEvery),
"notifywhenba... | go | {
"resource": ""
} |
q17842 | PostParams | train | func (ck *HttpCheck) PostParams() map[string]string {
params := ck.PutParams()
for k, v := range params {
if v == "" {
delete(params, k)
}
}
params["type"] = "http"
return params
} | go | {
"resource": ""
} |
q17843 | Valid | train | func (ck *HttpCheck) Valid() error {
if ck.Name == "" {
return fmt.Errorf("Invalid value for `Name`. Must contain non-empty string")
}
if ck.Hostname == "" {
return fmt.Errorf("Invalid value for `Hostname`. Must contain non-empty string")
}
if ck.Resolution != 1 && ck.Resolution != 5 && ck.Resolution != 15... | go | {
"resource": ""
} |
q17844 | PutParams | train | func (ck *PingCheck) PutParams() map[string]string {
m := map[string]string{
"name": ck.Name,
"host": ck.Hostname,
"resolution": strconv.Itoa(ck.Resolution),
"paused": strconv.FormatBool(ck.Paused),
"notifyagainevery": strconv.Itoa(ck.NotifyAgainEvery),
"notifywhenba... | go | {
"resource": ""
} |
q17845 | Valid | train | func (ck *PingCheck) Valid() error {
if ck.Name == "" {
return fmt.Errorf("Invalid value for `Name`. Must contain non-empty string")
}
if ck.Hostname == "" {
return fmt.Errorf("Invalid value for `Hostname`. Must contain non-empty string")
}
if ck.Resolution != 1 && ck.Resolution != 5 && ck.Resolution != 15... | go | {
"resource": ""
} |
q17846 | PutParams | train | func (ck *TCPCheck) PutParams() map[string]string {
m := map[string]string{
"name": ck.Name,
"host": ck.Hostname,
"resolution": strconv.Itoa(ck.Resolution),
"paused": strconv.FormatBool(ck.Paused),
"notifyagainevery": strconv.Itoa(ck.NotifyAgainEvery),
"notifywhenbac... | go | {
"resource": ""
} |
q17847 | Valid | train | func (ck *TCPCheck) Valid() error {
if ck.Name == "" {
return fmt.Errorf("invalid value for `Name`, must contain non-empty string")
}
if ck.Hostname == "" {
return fmt.Errorf("invalid value for `Hostname`, must contain non-empty string")
}
if ck.Resolution != 1 && ck.Resolution != 5 && ck.Resolution != 15 &&... | go | {
"resource": ""
} |
q17848 | Valid | train | func (csr SummaryPerformanceRequest) Valid() error {
if csr.Id == 0 {
return ErrMissingId
}
if csr.Resolution != "" && csr.Resolution != "hour" && csr.Resolution != "day" && csr.Resolution != "week" {
return ErrBadResolution
}
return nil
} | go | {
"resource": ""
} |
q17849 | GetParams | train | func (csr SummaryPerformanceRequest) GetParams() (params map[string]string) {
params = make(map[string]string)
if csr.Resolution != "" {
params["resolution"] = csr.Resolution
}
if csr.IncludeUptime {
params["includeuptime"] = "true"
}
return
} | go | {
"resource": ""
} |
q17850 | matchDnsaddr | train | func matchDnsaddr(maddr ma.Multiaddr, trailer []ma.Multiaddr) bool {
parts := ma.Split(maddr)
if ma.Join(parts[len(parts)-len(trailer):]...).Equal(ma.Join(trailer...)) {
return true
}
return false
} | go | {
"resource": ""
} |
q17851 | DiscoverGateway | train | func DiscoverGateway() (NAT, error) {
select {
case nat := <-discoverUPNP_IG1():
return nat, nil
case nat := <-discoverUPNP_IG2():
return nat, nil
case nat := <-discoverUPNP_GenIGDev():
return nat, nil
case nat := <-discoverNATPMP():
return nat, nil
case <-time.After(10 * time.Second):
return nil, ErrNo... | go | {
"resource": ""
} |
q17852 | Insert | train | func (IS *InvertedSuffix) Insert(Word, Result string, Data interface{}) {
Query := IS.Converter(Word)
low, high := IS.Search(Query)
for k := low; k < high; k++ {
if IS.Results[IS.WordIndex[k]] == Word {
IS.Values[IS.WordIndex[k]] = Data
return
}
}
i := len(IS.Words)
IS.Words = append(IS.Words, Query)
L... | go | {
"resource": ""
} |
q17853 | ErrorCorrect | train | func ErrorCorrect(Word []byte, AllowedBytes []byte) [][]byte {
results := make([][]byte, 0)
N := len(Word)
for i := 0; i < N; i++ {
t := Word[i]
// Remove Character
temp := make([]byte, N)
copy(temp, Word)
temp = append(temp[:i], temp[i+1:]...)
results = append(results, temp)
if i != 0 {
// Add Char... | go | {
"resource": ""
} |
q17854 | ToASCII | train | func ToASCII(r rune) rune {
a, ok := UnicodeToASCII[r]
if ok {
return a
}
return r
} | go | {
"resource": ""
} |
q17855 | UnicodeToLowerASCII | train | func UnicodeToLowerASCII(s string) []byte {
return []byte(strings.Map(func(r rune) rune { return unicode.ToLower(ToASCII(r)) }, s))
} | go | {
"resource": ""
} |
q17856 | New | train | func New(
ip string,
selfNodeId types.NodeId,
genNumber uint64,
gossipIntervals types.GossipIntervals,
gossipVersion string,
clusterId string,
selfFailureDomain string,
) Gossiper {
g := new(proto.GossiperImpl)
g.Init(ip, selfNodeId, genNumber, gossipIntervals, gossipVersion, clusterId, selfFailureDomain)
ret... | go | {
"resource": ""
} |
q17857 | NodeMeta | train | func (gd *GossipDelegate) NodeMeta(limit int) []byte {
msg := gd.MetaInfo()
msgBytes, _ := gd.convertToBytes(msg)
return msgBytes
} | go | {
"resource": ""
} |
q17858 | NotifyJoin | train | func (gd *GossipDelegate) NotifyJoin(node *memberlist.Node) {
// Ignore self NotifyJoin
nodeName := gd.parseMemberlistNodeName(node.Name)
if nodeName == gd.nodeId {
return
}
gd.updateGossipTs()
// NotifyAlive should remove a node from memberlist if the
// gossip version mismatches.
// Nevertheless we are do... | go | {
"resource": ""
} |
q17859 | NotifyLeave | train | func (gd *GossipDelegate) NotifyLeave(node *memberlist.Node) {
nodeName := gd.parseMemberlistNodeName(node.Name)
if nodeName == gd.nodeId {
gd.triggerStateEvent(types.SELF_LEAVE)
} else {
if gd.quorumProvider.Type() == types.QUORUM_PROVIDER_FAILURE_DOMAINS {
go func() {
isSuspect := gd.isClusterDomainSusp... | go | {
"resource": ""
} |
q17860 | isClusterDomainSuspectDown | train | func (gd *GossipDelegate) isClusterDomainSuspectDown(nodeId types.NodeId) bool {
nodeInfo, err := gd.GetLocalNodeInfo(nodeId)
if err != nil {
// Node not found in our map
// No need of putting it as a suspect
// We will mark it as Offline immediately
return false
}
if !gd.quorumProvider.IsDomainActive(nodeI... | go | {
"resource": ""
} |
q17861 | NewProbationManager | train | func NewProbationManager(
name string,
probationTimeout time.Duration,
pcf CallbackFn,
) Probation {
if sched.Instance() == nil {
sched.Init(1 * time.Second)
}
p := &probation{
name: name,
probationTimeout: probationTimeout,
pcf: pcf,
probationTasks: make(map[string]sched.Task... | go | {
"resource": ""
} |
q17862 | isDomainActive | train | func (f *failureDomainsQuorum) isDomainActive(ipDomain string) bool {
isActive, _ := f.activeMap[ipDomain]
if isActive == types.CLUSTER_DOMAIN_STATE_ACTIVE {
return true
}
return false
} | go | {
"resource": ""
} |
q17863 | NewQuorumProvider | train | func NewQuorumProvider(
selfId types.NodeId,
provider types.QuorumProvider,
) Quorum {
if provider == types.QUORUM_PROVIDER_DEFAULT {
return &defaultQuorum{
selfId: selfId,
}
}
return &failureDomainsQuorum{
selfId: selfId,
}
} | go | {
"resource": ""
} |
q17864 | computeRolloverTime | train | func (self *TimedRotatingFileHandler) computeRolloverTime(
currentTime time.Time) time.Time {
result := currentTime.Add(self.interval)
// If we are rolling over at midnight or weekly, then the interval is
// already known. What we need to figure out is WHEN the next interval is.
// In other words, if you are rol... | go | {
"resource": ""
} |
q17865 | ShouldRollover | train | func (self *TimedRotatingFileHandler) ShouldRollover(
record *LogRecord) (bool, string) {
overTime := time.Now().After(self.rolloverTime)
return overTime, self.Format(record)
} | go | {
"resource": ""
} |
q17866 | getFilesToDelete | train | func (self *TimedRotatingFileHandler) getFilesToDelete() ([]string, error) {
dirName, baseName := filepath.Split(self.GetFilePath())
fileInfos, err := ioutil.ReadDir(dirName)
if err != nil {
return nil, err
}
prefix := baseName + "."
pattern, err := regexp.Compile(self.extMatch)
if err != nil {
return nil, e... | go | {
"resource": ""
} |
q17867 | Emit | train | func (self *SyslogHandler) Emit(record *LogRecord) error {
message := self.BaseHandler.Format(record)
var err error
switch record.Level {
case LevelFatal:
err = self.writer.Crit(message)
case LevelError:
err = self.writer.Err(message)
case LevelWarn:
err = self.writer.Warning(message)
case LevelInfo:
err... | go | {
"resource": ""
} |
q17868 | NewBaseRotatingHandler | train | func NewBaseRotatingHandler(
filepath string, mode, bufferSize int) (*BaseRotatingHandler, error) {
fileHandler, err := NewFileHandler(filepath, mode, bufferSize)
if err != nil {
return nil, err
}
object := &BaseRotatingHandler{
FileHandler: fileHandler,
}
Closer.RemoveHandler(object.FileHandler)
Closer.Ad... | go | {
"resource": ""
} |
q17869 | RolloverEmit | train | func (self *BaseRotatingHandler) RolloverEmit(
handler RotatingHandler, record *LogRecord) error {
// We don't use the implementation of StreamHandler.Emit2() but directly
// write to stream here in order to avoid calling self.Format() twice
// for performance optimization.
doRollover, message := handler.ShouldRo... | go | {
"resource": ""
} |
q17870 | ShouldRollover | train | func (self *RotatingFileHandler) ShouldRollover(
record *LogRecord) (bool, string) {
message := self.Format(record)
if self.maxBytes > 0 {
offset, err := self.GetStream().Tell()
if err != nil {
// don't trigger rollover action if we lose offset info
return false, message
}
if (uint64(offset) + uint64(... | go | {
"resource": ""
} |
q17871 | RotateFile | train | func (self *RotatingFileHandler) RotateFile(sourceFile, destFile string) error {
if FileExists(sourceFile) {
if FileExists(destFile) {
if err := os.Remove(destFile); err != nil {
return err
}
}
if err := os.Rename(sourceFile, destFile); err != nil {
return err
}
}
return nil
} | go | {
"resource": ""
} |
q17872 | DoRollover | train | func (self *RotatingFileHandler) DoRollover() (err error) {
self.FileHandler.Close()
defer func() {
if e := self.FileHandler.Open(); e != nil {
if e == nil {
err = e
}
}
}()
if self.backupCount > 0 {
filepath := self.GetFilePath()
for i := self.backupCount - 1; i > 0; i-- {
sourceFile := fmt.Sp... | go | {
"resource": ""
} |
q17873 | NewSocketHandler | train | func NewSocketHandler(host string, port uint16) *SocketHandler {
retry := NewErrorRetry().
Delay(SocketDefaultDelay).
Deadline(SocketDefaultMaxDeadline)
object := &SocketHandler{
BaseHandler: NewBaseHandler("", LevelNotset),
host: host,
port: port,
closeOnError: true,
retry: retr... | go | {
"resource": ""
} |
q17874 | Marshal | train | func (self *SocketHandler) Marshal(record *LogRecord) ([]byte, error) {
r := SocketLogRecord{
CreatedTime: record.CreatedTime,
AscTime: record.AscTime,
Name: record.Name,
Level: record.Level,
PathName: record.PathName,
FileName: record.FileName,
LineNo: record.LineNo,
FuncNa... | go | {
"resource": ""
} |
q17875 | makeSocket | train | func (self *SocketHandler) makeSocket(network string) error {
address := fmt.Sprintf("%s:%d", self.host, self.port)
conn, err := net.DialTimeout(network, address, SocketDefaultTimeout)
if err != nil {
return err
}
self.conn = conn
return nil
} | go | {
"resource": ""
} |
q17876 | sendTCP | train | func (self *SocketHandler) sendTCP(bin []byte) error {
if self.conn == nil {
err := self.createSocket()
if err != nil {
return err
}
}
sentSoFar, left := 0, len(bin)
for left > 0 {
sent, err := self.conn.Write(bin[sentSoFar:])
if err != nil {
return err
}
sentSoFar += sent
left -= sent
}
ret... | go | {
"resource": ""
} |
q17877 | sendUDP | train | func (self *SocketHandler) sendUDP(bin []byte) error {
if self.conn == nil {
err := self.createSocket()
if err != nil {
return err
}
}
_, err := self.conn.Write(bin)
return err
} | go | {
"resource": ""
} |
q17878 | Emit | train | func (self *SocketHandler) Emit(record *LogRecord) error {
self.Format(record)
bin, err := self.Marshal(record)
if err != nil {
return err
}
return self.sendFunc(bin)
} | go | {
"resource": ""
} |
q17879 | HandleError | train | func (self *SocketHandler) HandleError(record *LogRecord, err error) {
if self.closeOnError && (self.conn != nil) {
self.conn.Close()
self.conn = nil
} else {
self.BaseHandler.HandleError(record, err)
}
} | go | {
"resource": ""
} |
q17880 | Close | train | func (self *SocketHandler) Close() {
self.Lock()
defer self.Unlock()
if self.conn != nil {
self.conn.Close()
self.conn = nil
}
self.BaseHandler.Close()
} | go | {
"resource": ""
} |
q17881 | Filter | train | func (self *NameFilter) Filter(record *LogRecord) bool {
length := len(self.name)
if length == 0 {
return true
} else if self.name == record.Name {
return true
} else if !strings.HasPrefix(record.Name, self.name) {
return false
}
return (record.Name[length] == '.')
} | go | {
"resource": ""
} |
q17882 | AddFilter | train | func (self *StandardFilterer) AddFilter(filter Filter) {
if !self.filters.SetContains(filter) {
self.filters.SetAdd(filter)
}
} | go | {
"resource": ""
} |
q17883 | RemoveFilter | train | func (self *StandardFilterer) RemoveFilter(filter Filter) {
if self.filters.SetContains(filter) {
self.filters.SetRemove(filter)
}
} | go | {
"resource": ""
} |
q17884 | GetLogger | train | func GetLogger(name string) Logger {
if len(name) > 0 {
return manager.GetLogger(name)
} else {
return root
}
} | go | {
"resource": ""
} |
q17885 | Logf | train | func Logf(level LogLevelType, format string, args ...interface{}) {
root.Logf(level, format, args...)
} | go | {
"resource": ""
} |
q17886 | NewFileHandler | train | func NewFileHandler(filename string, mode int, bufferSize int) (*FileHandler, error) {
// keep the absolute path, otherwise derived classes which use this
// may come a cropper when the current directory changes.
filepath, err := filepath.Abs(filename)
if err != nil {
return nil, err
}
handler := NewStreamHandl... | go | {
"resource": ""
} |
q17887 | ApplyConfigFile | train | func ApplyConfigFile(file string) error {
ext := filepath.Ext(file)
switch ext {
case ".json":
return ApplyJsonConfigFile(file)
case ".yml":
fallthrough
case ".yaml":
return ApplyYAMLConfigFile(file)
default:
return errors.New(fmt.Sprintf(
"unknown format of the specified file: %s", file))
}
} | go | {
"resource": ""
} |
q17888 | ApplyJsonConfigFile | train | func ApplyJsonConfigFile(file string) error {
bin, err := ioutil.ReadFile(file)
if err != nil {
return err
}
decoder := json.NewDecoder(bytes.NewBuffer(bin))
decoder.UseNumber()
var conf Conf
if err = decoder.Decode(&conf); err != nil {
return err
}
return DictConfig(&conf)
} | go | {
"resource": ""
} |
q17889 | ApplyYAMLConfigFile | train | func ApplyYAMLConfigFile(file string) error {
bin, err := ioutil.ReadFile(file)
if err != nil {
return err
}
var conf Conf
if err = yaml.Unmarshal(bin, &conf); err != nil {
return err
}
return DictConfig(&conf)
} | go | {
"resource": ""
} |
q17890 | NewBaseHandler | train | func NewBaseHandler(name string, level LogLevelType) *BaseHandler {
return &BaseHandler{
StandardFilterer: NewStandardFilterer(),
name: name,
level: level,
formatter: nil,
}
} | go | {
"resource": ""
} |
q17891 | Format | train | func (self *BaseHandler) Format(record *LogRecord) string {
self.formatterLock.RLock()
defer self.formatterLock.RUnlock()
var formatter Formatter
if self.formatter != nil {
formatter = self.formatter
} else {
formatter = defaultFormatter
}
return formatter.Format(record)
} | go | {
"resource": ""
} |
q17892 | AddLevel | train | func AddLevel(level LogLevelType, levelName string) {
levelLock.Lock()
defer levelLock.Unlock()
levelToNames[level] = levelName
nameToLevels[levelName] = level
} | go | {
"resource": ""
} |
q17893 | NewPlaceHolder | train | func NewPlaceHolder(logger Logger) *PlaceHolder {
object := &PlaceHolder{
Loggers: NewListSet(),
}
object.Append(logger)
return object
} | go | {
"resource": ""
} |
q17894 | Append | train | func (self *PlaceHolder) Append(logger Logger) {
if !self.Loggers.SetContains(logger) {
self.Loggers.SetAdd(logger)
}
} | go | {
"resource": ""
} |
q17895 | findCaller | train | func findCaller() *CallerInfo {
for i := 3; ; i++ {
pc, filepath, line, ok := runtime.Caller(i)
if !ok {
return UnknownCallerInfo
}
parts := strings.Split(filepath, "/")
dir := parts[len(parts)-2]
file := parts[len(parts)-1]
if (dir != thisPackageName) || (file != thisFileName) {
funcName := runtim... | go | {
"resource": ""
} |
q17896 | NewStandardLogger | train | func NewStandardLogger(name string, level LogLevelType) *StandardLogger {
object := &StandardLogger{
StandardFilterer: NewStandardFilterer(),
parent: nil,
name: name,
findCallerFunc: findCaller,
level: level,
propagate: true,
handlers: NewListSet(),
man... | go | {
"resource": ""
} |
q17897 | GetEffectiveLevel | train | func (self *StandardLogger) GetEffectiveLevel() LogLevelType {
self.lock.RLock()
defer self.lock.RUnlock()
var logger Logger = self
for logger != nil {
level := logger.GetLevel()
if level != LevelNotset {
return level
}
logger = logger.GetParent()
}
return LevelNotset
} | go | {
"resource": ""
} |
q17898 | traverseHandlers | train | func (self *StandardLogger) traverseHandlers(record *LogRecord) {
var call Logger = self
for call != nil {
call.CallHandlers(record)
if !call.GetPropagate() {
call = nil
} else {
call = call.GetParent()
}
}
} | go | {
"resource": ""
} |
q17899 | NewRootLogger | train | func NewRootLogger(level LogLevelType) *RootLogger {
logger := NewStandardLogger("root", level)
logger.SetPropagate(false)
return &RootLogger{
StandardLogger: logger,
}
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.