_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q20200 | Fixed | train | func Fixed(c *cli.Context) {
hostsfile := AlwaysLoadHostFile(c)
if bytes.Equal(hostsfile.GetData(), hostsfile.Format()) {
MaybePrintln(c, fmt.Sprintf("%s is already formatted and contains no dupes or conflicts", GetHostsPath()))
os.Exit(0)
} else {
MaybePrintln(c, fmt.Sprintf("%s is not formatted. Use hostess ... | go | {
"resource": ""
} |
q20201 | Dump | train | func Dump(c *cli.Context) {
hostsfile := AlwaysLoadHostFile(c)
jsonbytes, err := hostsfile.Hosts.Dump()
if err != nil {
MaybeError(c, err.Error())
}
fmt.Println(fmt.Sprintf("%s", jsonbytes))
} | go | {
"resource": ""
} |
q20202 | Apply | train | func Apply(c *cli.Context) {
if len(c.Args()) != 1 {
MaybeError(c, "Usage should be apply [filename]")
}
filename := c.Args()[0]
jsonbytes, err := ioutil.ReadFile(filename)
if err != nil {
MaybeError(c, fmt.Sprintf("Unable to read %s: %s", filename, err))
}
hostfile := AlwaysLoadHostFile(c)
err = hostfile... | go | {
"resource": ""
} |
q20203 | MustParseLine | train | func MustParseLine(line string) Hostlist {
hostlist, err := ParseLine(line)
if err != nil {
panic(err)
}
return hostlist
} | go | {
"resource": ""
} |
q20204 | Read | train | func (h *Hostfile) Read() error {
data, err := ioutil.ReadFile(h.Path)
if err == nil {
h.data = data
}
return err
} | go | {
"resource": ""
} |
q20205 | Less | train | func (h Hostlist) Less(A, B int) bool {
// Sort IPv4 before IPv6
// A is IPv4 and B is IPv6. A wins!
if !h[A].IPv6 && h[B].IPv6 {
return true
}
// A is IPv6 but B is IPv4. A loses!
if h[A].IPv6 && !h[B].IPv6 {
return false
}
// Sort "localhost" at the top
if h[A].Domain == "localhost" {
return true
}
... | go | {
"resource": ""
} |
q20206 | Swap | train | func (h Hostlist) Swap(i, j int) {
h[i], h[j] = h[j], h[i]
} | go | {
"resource": ""
} |
q20207 | Contains | train | func (h *Hostlist) Contains(b *Hostname) bool {
for _, a := range *h {
if a.Equal(b) {
return true
}
}
return false
} | go | {
"resource": ""
} |
q20208 | ContainsDomain | train | func (h *Hostlist) ContainsDomain(domain string) bool {
for _, hostname := range *h {
if hostname.Domain == domain {
return true
}
}
return false
} | go | {
"resource": ""
} |
q20209 | ContainsIP | train | func (h *Hostlist) ContainsIP(IP net.IP) bool {
for _, hostname := range *h {
if hostname.EqualIP(IP) {
return true
}
}
return false
} | go | {
"resource": ""
} |
q20210 | IndexOf | train | func (h *Hostlist) IndexOf(host *Hostname) int {
for index, found := range *h {
if found.Equal(host) {
return index
}
}
return -1
} | go | {
"resource": ""
} |
q20211 | IndexOfDomainV | train | func (h *Hostlist) IndexOfDomainV(domain string, version int) int {
if version != 4 && version != 6 {
panic(ErrInvalidVersionArg)
}
for index, hostname := range *h {
if hostname.Domain == domain && hostname.IPv6 == (version == 6) {
return index
}
}
return -1
} | go | {
"resource": ""
} |
q20212 | RemoveDomain | train | func (h *Hostlist) RemoveDomain(domain string) int {
return h.RemoveDomainV(domain, 4) + h.RemoveDomainV(domain, 6)
} | go | {
"resource": ""
} |
q20213 | RemoveDomainV | train | func (h *Hostlist) RemoveDomainV(domain string, version int) int {
return h.Remove(h.IndexOfDomainV(domain, version))
} | go | {
"resource": ""
} |
q20214 | Enable | train | func (h *Hostlist) Enable(domain string) bool {
found := false
for _, hostname := range *h {
if hostname.Domain == domain {
hostname.Enabled = true
found = true
}
}
return found
} | go | {
"resource": ""
} |
q20215 | EnableV | train | func (h *Hostlist) EnableV(domain string, version int) bool {
found := false
if version != 4 && version != 6 {
panic(ErrInvalidVersionArg)
}
for _, hostname := range *h {
if hostname.Domain == domain && hostname.IPv6 == (version == 6) {
hostname.Enabled = true
found = true
}
}
return found
} | go | {
"resource": ""
} |
q20216 | FilterByIP | train | func (h *Hostlist) FilterByIP(IP net.IP) (hostnames []*Hostname) {
for _, hostname := range *h {
if hostname.IP.Equal(IP) {
hostnames = append(hostnames, hostname)
}
}
return
} | go | {
"resource": ""
} |
q20217 | FilterByDomain | train | func (h *Hostlist) FilterByDomain(domain string) (hostnames []*Hostname) {
for _, hostname := range *h {
if hostname.Domain == domain {
hostnames = append(hostnames, hostname)
}
}
return
} | go | {
"resource": ""
} |
q20218 | FilterByDomainV | train | func (h *Hostlist) FilterByDomainV(domain string, version int) (hostnames []*Hostname) {
if version != 4 && version != 6 {
panic(ErrInvalidVersionArg)
}
for _, hostname := range *h {
if hostname.Domain == domain && hostname.IPv6 == (version == 6) {
hostnames = append(hostnames, hostname)
}
}
return
} | go | {
"resource": ""
} |
q20219 | Apply | train | func (h *Hostlist) Apply(jsonbytes []byte) error {
var hostnames Hostlist
err := json.Unmarshal(jsonbytes, &hostnames)
if err != nil {
return err
}
for _, hostname := range hostnames {
h.Add(hostname)
}
return nil
} | go | {
"resource": ""
} |
q20220 | LogWithBarker | train | func LogWithBarker(b bark.Logger, msg string) {
b.Error(fmt.Sprintf("logged from helper: %s", msg))
} | go | {
"resource": ""
} |
q20221 | LogWithZapper | train | func LogWithZapper(z *zap.Logger, msg string) {
z.Error(fmt.Sprintf("logged from helper: %s", msg))
} | go | {
"resource": ""
} |
q20222 | NewNopLogger | train | func NewNopLogger() Logger {
return NewLoggerFromLogrus(&logrus.Logger{
Out: ioutil.Discard,
Formatter: new(logrus.JSONFormatter),
Level: logrus.DebugLevel,
})
} | go | {
"resource": ""
} |
q20223 | Barkify | train | func Barkify(l *zap.Logger) bark.Logger {
if z, ok := l.Core().(*zapper); ok {
return z.l
}
return barker{l.WithOptions(zap.AddCallerSkip(_barkifyCallerSkip)).Sugar()}
} | go | {
"resource": ""
} |
q20224 | IsSet | train | func (o *ArchiveOpts) IsSet() bool {
return len(o.Exclude) > 0 || len(o.Include) > 0 || o.VCS
} | go | {
"resource": ""
} |
q20225 | CreateArchive | train | func CreateArchive(path string, opts *ArchiveOpts) (*Archive, error) {
log.Printf("[INFO] creating archive from %s", path)
// Dereference any symlinks and determine the real path and info
fi, err := os.Lstat(path)
if err != nil {
return nil, err
}
if fi.Mode()&os.ModeSymlink != 0 {
path, fi, err = readLinkFu... | go | {
"resource": ""
} |
q20226 | CreateApp | train | func (c *Client) CreateApp(user, name string) (*App, error) {
log.Printf("[INFO] creating application %s/%s", user, name)
body, err := json.Marshal(&appWrapper{&App{
User: user,
Name: name,
}})
if err != nil {
return nil, err
}
endpoint := "/api/v1/vagrant/applications"
request, err := c.Request("POST", ... | go | {
"resource": ""
} |
q20227 | UploadApp | train | func (c *Client) UploadApp(app *App, metadata map[string]interface{},
data io.Reader, size int64) (uint64, error) {
log.Printf("[INFO] uploading application %s (%d bytes) with metadata %q",
app.Slug(), size, metadata)
endpoint := fmt.Sprintf("/api/v1/vagrant/applications/%s/%s/versions",
app.User, app.Name)
... | go | {
"resource": ""
} |
q20228 | DefaultClient | train | func DefaultClient() *Client {
atlasEndpoint := os.Getenv(atlasEndpointEnvVar)
if atlasEndpoint == "" {
atlasEndpoint = atlasDefaultEndpoint
}
client, err := NewClient(atlasEndpoint)
if err != nil {
panic(err)
}
return client
} | go | {
"resource": ""
} |
q20229 | Request | train | func (c *Client) Request(verb, spath string, ro *RequestOptions) (*http.Request, error) {
log.Printf("[INFO] request: %s %s", verb, spath)
// Ensure we have a RequestOptions struct (passing nil is an acceptable)
if ro == nil {
ro = new(RequestOptions)
}
// Create a new URL with the appended path
u := *c.URL
... | go | {
"resource": ""
} |
q20230 | rawRequest | train | func (c *Client) rawRequest(verb string, u *url.URL, ro *RequestOptions) (*http.Request, error) {
if verb == "" {
return nil, fmt.Errorf("client: missing verb")
}
if u == nil {
return nil, fmt.Errorf("client: missing URL.url")
}
if ro == nil {
return nil, fmt.Errorf("client: missing RequestOptions")
}
/... | go | {
"resource": ""
} |
q20231 | parseErr | train | func parseErr(r *http.Response) error {
re := &RailsError{}
if err := decodeJSON(r, &re); err != nil {
return fmt.Errorf("error decoding JSON body: %s", err)
}
return re
} | go | {
"resource": ""
} |
q20232 | BuildConfig | train | func (c *Client) BuildConfig(user, name string) (*BuildConfig, error) {
log.Printf("[INFO] getting build configuration %s/%s", user, name)
endpoint := fmt.Sprintf("/api/v1/packer/build-configurations/%s/%s", user, name)
request, err := c.Request("GET", endpoint, nil)
if err != nil {
return nil, err
}
response... | go | {
"resource": ""
} |
q20233 | CreateBuildConfig | train | func (c *Client) CreateBuildConfig(user, name string) (*BuildConfig, error) {
log.Printf("[INFO] creating build configuration %s/%s", user, name)
endpoint := "/api/v1/packer/build-configurations"
body, err := json.Marshal(&bcWrapper{
BuildConfig: &BuildConfig{
User: user,
Name: name,
},
})
if err != nil... | go | {
"resource": ""
} |
q20234 | MarshalJSON | train | func (o *UploadArtifactOpts) MarshalJSON() ([]byte, error) {
return json.Marshal(map[string]interface{}{
"artifact_version": map[string]interface{}{
"id": o.ID,
"file": o.File != nil,
"metadata": o.Metadata,
"build_id": o.BuildID,
"compile_id": o.CompileID,
},
})
} | go | {
"resource": ""
} |
q20235 | Artifact | train | func (c *Client) Artifact(user, name string) (*Artifact, error) {
endpoint := fmt.Sprintf("/api/v1/artifacts/%s/%s", user, name)
request, err := c.Request("GET", endpoint, nil)
if err != nil {
return nil, err
}
response, err := checkResp(c.HTTPClient.Do(request))
if err != nil {
return nil, err
}
var aw a... | go | {
"resource": ""
} |
q20236 | ArtifactSearch | train | func (c *Client) ArtifactSearch(opts *ArtifactSearchOpts) ([]*ArtifactVersion, error) {
log.Printf("[INFO] searching artifacts: %#v", opts)
params := make(map[string]string)
if opts.Version != "" {
params["version"] = opts.Version
}
if opts.Build != "" {
params["build"] = opts.Build
}
i := 1
for k, v := r... | go | {
"resource": ""
} |
q20237 | CreateArtifact | train | func (c *Client) CreateArtifact(user, name string) (*Artifact, error) {
log.Printf("[INFO] creating artifact: %s/%s", user, name)
body, err := json.Marshal(&artifactWrapper{&Artifact{
User: user,
Name: name,
}})
if err != nil {
return nil, err
}
endpoint := "/api/v1/artifacts"
request, err := c.Request("P... | go | {
"resource": ""
} |
q20238 | ArtifactFileURL | train | func (c *Client) ArtifactFileURL(av *ArtifactVersion) (*url.URL, error) {
if !av.File {
return nil, nil
}
u := *c.URL
u.Path = fmt.Sprintf("/api/v1/artifacts/%s/%s/%s/%d/file",
av.User, av.Name, av.Type, av.Version)
return &u, nil
} | go | {
"resource": ""
} |
q20239 | UploadArtifact | train | func (c *Client) UploadArtifact(opts *UploadArtifactOpts) (*ArtifactVersion, error) {
log.Printf("[INFO] uploading artifact: %s/%s (%s)", opts.User, opts.Name, opts.Type)
endpoint := fmt.Sprintf("/api/v1/artifacts/%s/%s/%s",
opts.User, opts.Name, opts.Type)
body, err := json.Marshal(opts)
if err != nil {
retu... | go | {
"resource": ""
} |
q20240 | CreateTerraformConfigVersion | train | func (c *Client) CreateTerraformConfigVersion(
user string, name string,
version *TerraformConfigVersion,
data io.Reader, size int64) (int, error) {
log.Printf("[INFO] creating terraform configuration %s/%s", user, name)
endpoint := fmt.Sprintf(
"/api/v1/terraform/configurations/%s/%s/versions", user, name)
bo... | go | {
"resource": ""
} |
q20241 | Login | train | func (c *Client) Login(username, password string) (string, error) {
log.Printf("[INFO] logging in user %s", username)
if len(username) == 0 {
return "", fmt.Errorf("client: missing username")
}
if len(password) == 0 {
return "", fmt.Errorf("client: missing password")
}
// Make a request
request, err := c.... | go | {
"resource": ""
} |
q20242 | Verify | train | func (c *Client) Verify() error {
log.Printf("[INFO] verifying authentication")
request, err := c.Request("GET", "/api/v1/authenticate", nil)
if err != nil {
return err
}
_, err = checkResp(c.HTTPClient.Do(request))
return err
} | go | {
"resource": ""
} |
q20243 | vcsDetect | train | func vcsDetect(path string) (*VCS, error) {
dir := path
for {
for _, v := range VCSList {
for _, f := range v.Detect {
check := filepath.Join(dir, f)
if _, err := os.Stat(check); err == nil {
return v, nil
}
}
}
lastDir := dir
dir = filepath.Dir(dir)
if dir == lastDir {
break
}
... | go | {
"resource": ""
} |
q20244 | vcsPreflight | train | func vcsPreflight(path string) error {
vcs, err := vcsDetect(path)
if err != nil {
return fmt.Errorf("error detecting VCS: %s", err)
}
if vcs.Preflight != nil {
return vcs.Preflight(path)
}
return nil
} | go | {
"resource": ""
} |
q20245 | vcsFiles | train | func vcsFiles(path string) ([]string, error) {
vcs, err := vcsDetect(path)
if err != nil {
return nil, fmt.Errorf("error detecting VCS: %s", err)
}
if vcs.Files != nil {
return vcs.Files(path)
}
return nil, nil
} | go | {
"resource": ""
} |
q20246 | vcsFilesCmd | train | func vcsFilesCmd(args ...string) VCSFilesFunc {
return func(path string) ([]string, error) {
var stderr, stdout bytes.Buffer
cmd := exec.Command(args[0], args[1:]...)
cmd.Dir = path
cmd.Stdout = &stdout
cmd.Stderr = &stderr
if err := cmd.Run(); err != nil {
return nil, fmt.Errorf(
"error executing ... | go | {
"resource": ""
} |
q20247 | vcsTrimCmd | train | func vcsTrimCmd(f VCSFilesFunc) VCSFilesFunc {
return func(path string) ([]string, error) {
absPath, err := filepath.Abs(path)
if err != nil {
return nil, fmt.Errorf(
"error expanding VCS path: %s", err)
}
// Now that we have the root path, get the inner files
fs, err := f(path)
if err != nil {
... | go | {
"resource": ""
} |
q20248 | vcsMetadata | train | func vcsMetadata(path string) (map[string]string, error) {
vcs, err := vcsDetect(path)
if err != nil {
return nil, fmt.Errorf("error detecting VCS: %s", err)
}
if vcs.Metadata != nil {
return vcs.Metadata(path)
}
return nil, nil
} | go | {
"resource": ""
} |
q20249 | gitBranch | train | func gitBranch(path string) (string, error) {
var stderr, stdout bytes.Buffer
cmd := exec.Command("git", "symbolic-ref", "--short", "HEAD")
cmd.Dir = path
cmd.Stdout = &stdout
cmd.Stderr = &stderr
if err := cmd.Run(); err != nil {
if strings.Contains(stderr.String(), ignorableDetachedHeadError) {
return "",... | go | {
"resource": ""
} |
q20250 | gitCommit | train | func gitCommit(path string) (string, error) {
var stderr, stdout bytes.Buffer
cmd := exec.Command("git", "log", "-n1", "--pretty=format:%H")
cmd.Dir = path
cmd.Stdout = &stdout
cmd.Stderr = &stderr
if err := cmd.Run(); err != nil {
return "", fmt.Errorf("error getting git commit: %s\nstdout: %s\nstderr: %s",
... | go | {
"resource": ""
} |
q20251 | gitRemotes | train | func gitRemotes(path string) (map[string]string, error) {
var stderr, stdout bytes.Buffer
cmd := exec.Command("git", "remote", "-v")
cmd.Dir = path
cmd.Stdout = &stdout
cmd.Stderr = &stderr
if err := cmd.Run(); err != nil {
return nil, fmt.Errorf("error getting git remotes: %s\nstdout: %s\nstderr: %s",
err,... | go | {
"resource": ""
} |
q20252 | gitPreflight | train | func gitPreflight(path string) error {
var stderr, stdout bytes.Buffer
cmd := exec.Command("git", "--version")
cmd.Dir = path
cmd.Stdout = &stdout
cmd.Stderr = &stderr
if err := cmd.Run(); err != nil {
return fmt.Errorf("error getting git version: %s\nstdout: %s\nstderr: %s",
err, stdout.String(), stderr.St... | go | {
"resource": ""
} |
q20253 | gitMetadata | train | func gitMetadata(path string) (map[string]string, error) {
// Future-self note: Git is NOT threadsafe, so we cannot run these
// operations in go routines or else you're going to have a really really
// bad day and Panda.State == "Sad" :(
branch, err := gitBranch(path)
if err != nil {
return nil, err
}
commi... | go | {
"resource": ""
} |
q20254 | RegisterMocker | train | func (c *Controller) RegisterMocker(m Mocker) {
c.Lock()
c.mockers = append(c.mockers, m)
c.Unlock()
} | go | {
"resource": ""
} |
q20255 | Finish | train | func (c *Controller) Finish() {
c.Lock()
for _, m := range c.mockers {
m.MinimockFinish()
}
c.Unlock()
} | go | {
"resource": ""
} |
q20256 | Wait | train | func (c *Controller) Wait(d time.Duration) {
wg := sync.WaitGroup{}
wg.Add(len(c.mockers))
for _, m := range c.mockers {
go func(m Mocker) {
defer wg.Done()
m.MinimockWait(d)
}(m)
}
wg.Wait()
} | go | {
"resource": ""
} |
q20257 | CamelToSnake | train | func CamelToSnake(s string) string {
b := buffer{
r: make([]byte, 0, len(s)),
}
var m rune
var w bool
for _, ch := range s {
if unicode.IsUpper(ch) {
if m != 0 {
if !w {
b.indent()
w = true
}
b.write(m)
}
m = unicode.ToLower(ch)
} else {
if m != 0 {
b.indent()
b.writ... | go | {
"resource": ""
} |
q20258 | checkDuplicateOutputFiles | train | func checkDuplicateOutputFiles(fileNames []string) error {
for i := range fileNames {
ok, err := isGoFile(fileNames[i])
if err != nil {
return err
}
if !ok {
continue
}
ipath, err := filepath.Abs(fileNames[i])
if err != nil {
return err
}
for j := range fileNames {
jpath, err := filepa... | go | {
"resource": ""
} |
q20259 | Equal | train | func Equal(a, b interface{}) bool {
if a == nil && b == nil {
return a == b
}
return reflect.DeepEqual(a, b)
} | go | {
"resource": ""
} |
q20260 | Diff | train | func Diff(e, a interface{}) string {
if e == nil || a == nil {
return ""
}
t := reflect.TypeOf(e)
k := t.Kind()
if reflect.TypeOf(a) != t {
return ""
}
if k == reflect.Ptr {
t = t.Elem()
k = t.Kind()
}
if k != reflect.Array && k != reflect.Map && k != reflect.Slice && k != reflect.Struct {
return... | go | {
"resource": ""
} |
q20261 | New | train | func New() http.Handler {
r := mux.NewRouter()
r.HandleFunc("/", actionHandler).Methods("GET", "POST")
r.HandleFunc("/{account}", actionHandler).Methods("GET", "POST")
r.HandleFunc("/queue/{queueName}", actionHandler).Methods("GET", "POST")
r.HandleFunc("/{account}/{queueName}", actionHandler).Methods("GET", "POS... | go | {
"resource": ""
} |
q20262 | IsSatisfiedBy | train | func (fp *FilterPolicy) IsSatisfiedBy(msgAttrs map[string]MessageAttributeValue) bool {
for policyAttrName, policyAttrValues := range *fp {
attrValue, ok := msgAttrs[policyAttrName]
if !ok {
return false // the attribute has to be present in the message
}
// String, String.Array, Number data-types are allo... | go | {
"resource": ""
} |
q20263 | shouldBreakThings | train | func (l *loki) shouldBreakThings() bool {
l.Lock()
defer l.Unlock()
l.callcount++
if l.callcount > 15 {
l.callcount = 0
return false
}
if l.callcount > 10 {
return true
}
return false
} | go | {
"resource": ""
} |
q20264 | Status | train | func (c *customCheck) Status() (interface{}, error) {
// perform some sort of check
if false {
return nil, fmt.Errorf("Something major just broke")
}
// You can return additional information pertaining to the check as long
// as it can be JSON marshalled
return map[string]int{"foo": 123, "bar": 456}, nil
} | go | {
"resource": ""
} |
q20265 | Status | train | func (d *DiskUsage) Status() (interface{}, error) {
stats, err := disk.Usage(d.Config.Path)
if err != nil {
return nil, fmt.Errorf("Error getting disk usage: %v", err)
}
diskUsage := stats.UsedPercent
if diskUsage >= d.Config.CriticalThreshold {
return nil, fmt.Errorf("Critical: disk usage too high %.2f per... | go | {
"resource": ""
} |
q20266 | New | train | func New() *Health {
return &Health{
Logger: log.NewSimple(),
configs: make([]*Config, 0),
states: make(map[string]State, 0),
runners: make(map[string]chan struct{}, 0),
active: newBool(),
statesLock: sync.Mutex{},
}
} | go | {
"resource": ""
} |
q20267 | AddCheck | train | func (h *Health) AddCheck(cfg *Config) error {
if h.active.val() {
return ErrNoAddCfgWhenActive
}
h.configs = append(h.configs, cfg)
return nil
} | go | {
"resource": ""
} |
q20268 | Stop | train | func (h *Health) Stop() error {
if !h.active.val() {
return ErrAlreadyStopped
}
for name, stop := range h.runners {
h.Logger.WithFields(log.Fields{"name": name}).Debug("Stopping checker")
close(stop)
}
// Reset runner map
h.runners = make(map[string]chan struct{}, 0)
// Reset states
h.safeResetStates()... | go | {
"resource": ""
} |
q20269 | Failed | train | func (h *Health) Failed() bool {
for _, val := range h.safeGetStates() {
if val.Fatal && val.isFailure() {
return true
}
}
return false
} | go | {
"resource": ""
} |
q20270 | safeResetStates | train | func (h *Health) safeResetStates() {
h.statesLock.Lock()
defer h.statesLock.Unlock()
h.states = make(map[string]State, 0)
} | go | {
"resource": ""
} |
q20271 | safeUpdateState | train | func (h *Health) safeUpdateState(stateEntry *State) {
// dispatch any status listeners
h.handleStatusListener(stateEntry)
// update states here
h.statesLock.Lock()
defer h.statesLock.Unlock()
h.states[stateEntry.Name] = *stateEntry
} | go | {
"resource": ""
} |
q20272 | safeGetStates | train | func (h *Health) safeGetStates() map[string]State {
h.statesLock.Lock()
defer h.statesLock.Unlock()
// deep copy h.states to avoid race
statesCopy := make(map[string]State, 0)
for k, v := range h.states {
statesCopy[k] = v
}
return statesCopy
} | go | {
"resource": ""
} |
q20273 | handleStatusListener | train | func (h *Health) handleStatusListener(stateEntry *State) {
// get the previous state
h.statesLock.Lock()
prevState := h.states[stateEntry.Name]
h.statesLock.Unlock()
// state is failure
if stateEntry.isFailure() {
if !prevState.isFailure() {
// new failure: previous state was ok
if h.StatusListener != ni... | go | {
"resource": ""
} |
q20274 | Status | train | func (r *Redis) Status() (interface{}, error) {
if r.Config.Ping {
if _, err := r.client.Ping().Result(); err != nil {
return nil, fmt.Errorf("Ping failed: %v", err)
}
}
if r.Config.Set != nil {
err := r.client.Set(r.Config.Set.Key, r.Config.Set.Value, r.Config.Set.Expiration).Err()
if err != nil {
re... | go | {
"resource": ""
} |
q20275 | NewReachableChecker | train | func NewReachableChecker(cfg *ReachableConfig) (*ReachableChecker, error) {
t := ReachableDefaultTimeout
if cfg.Timeout != 0 {
t = cfg.Timeout
}
d := net.DialTimeout
if cfg.Dialer != nil {
d = cfg.Dialer
}
n := ReachableDefaultNetwork
if cfg.Network != "" {
n = cfg.Network
}
r := &ReachableChecker{
di... | go | {
"resource": ""
} |
q20276 | Status | train | func (r *ReachableChecker) Status() (interface{}, error) {
// We must provide a port so when a port is not set in the URL provided use
// the default port (80)
port := r.url.Port()
if len(port) == 0 {
port = ReachableDefaultPort
}
conn, err := r.dialer(r.network, r.url.Hostname()+":"+port, r.timeout)
if err !... | go | {
"resource": ""
} |
q20277 | Status | train | func (h *HTTP) Status() (interface{}, error) {
resp, err := h.do()
if err != nil {
return nil, err
}
defer resp.Body.Close()
// Check if StatusCode matches
if resp.StatusCode != h.Config.StatusCode {
return nil, fmt.Errorf("Received status code '%v' does not match expected status code '%v'",
resp.StatusCo... | go | {
"resource": ""
} |
q20278 | DefaultQueryHandler | train | func DefaultQueryHandler(rows *sql.Rows) (bool, error) {
defer rows.Close()
numRows := 0
for rows.Next() {
numRows++
}
return numRows == 1, nil
} | go | {
"resource": ""
} |
q20279 | DefaultExecHandler | train | func DefaultExecHandler(result sql.Result) (bool, error) {
affectedRows, err := result.RowsAffected()
if err != nil {
return false, err
}
return affectedRows == int64(1), nil
} | go | {
"resource": ""
} |
q20280 | validateSQLConfig | train | func validateSQLConfig(cfg *SQLConfig) error {
if cfg == nil {
return fmt.Errorf("config is required")
}
if cfg.Execer == nil && cfg.Queryer == nil && cfg.Pinger == nil {
return fmt.Errorf("one of Execer, Queryer, or Pinger is required in SQLConfig")
}
if (cfg.Execer != nil || cfg.Queryer != nil) && len(cfg.... | go | {
"resource": ""
} |
q20281 | Status | train | func (s *SQL) Status() (interface{}, error) {
if err := validateSQLConfig(s.Config); err != nil {
return nil, err
}
switch {
// check for SQLExecer first
case s.Config.Execer != nil:
// if the result handler is nil, use the default
if s.Config.ExecerResultHandler == nil {
s.Config.ExecerResultHandler = D... | go | {
"resource": ""
} |
q20282 | runExecer | train | func (s *SQL) runExecer() (interface{}, error) {
ctx := context.Background()
result, err := s.Config.Execer.ExecContext(ctx, s.Config.Query, s.Config.Params...)
if err != nil {
return nil, err
}
ok, err := s.Config.ExecerResultHandler(result)
if err != nil {
return nil, err
}
if !ok {
return nil, fmt.Er... | go | {
"resource": ""
} |
q20283 | runQueryer | train | func (s *SQL) runQueryer() (interface{}, error) {
ctx := context.Background()
rows, err := s.Config.Queryer.QueryContext(ctx, s.Config.Query, s.Config.Params...)
if err != nil {
return nil, err
}
// the BYO result handler is responsible for closing the rows
ok, err := s.Config.QueryerResultHandler(rows)
if e... | go | {
"resource": ""
} |
q20284 | HealthCheckRecovered | train | func (sl *HealthCheckStatusListener) HealthCheckRecovered(entry *health.State, recordedFailures int64, failureDurationSeconds float64) {
svcLogger.Printf("Recovering from %d contiguous errors, lasting %1.2f seconds: %+v", recordedFailures, failureDurationSeconds, entry)
} | go | {
"resource": ""
} |
q20285 | NewEncoder | train | func NewEncoder() *Encoder {
e := &Encoder{
tagName: "form",
mode: ModeImplicit,
structCache: newStructCacheMap(),
embedAnonymous: true,
}
e.dataPool = &sync.Pool{New: func() interface{} {
return &encoder{
e: e,
namespace: make([]byte, 0, 64),
}
}}
return e
} | go | {
"resource": ""
} |
q20286 | Encode | train | func (e *Encoder) Encode(v interface{}) (values url.Values, err error) {
val, kind := ExtractType(reflect.ValueOf(v))
if kind == reflect.Ptr || kind == reflect.Interface || kind == reflect.Invalid {
return nil, &InvalidEncodeError{reflect.TypeOf(v)}
}
enc := e.dataPool.Get().(*encoder)
enc.values = make(url.V... | go | {
"resource": ""
} |
q20287 | NewDecoder | train | func NewDecoder() *Decoder {
d := &Decoder{
tagName: "form",
mode: ModeImplicit,
structCache: newStructCacheMap(),
maxArraySize: 10000,
}
d.dataPool = &sync.Pool{New: func() interface{} {
return &decoder{
d: d,
namespace: make([]byte, 0, 64),
}
}}
return d
} | go | {
"resource": ""
} |
q20288 | ExtractType | train | func ExtractType(current reflect.Value) (reflect.Value, reflect.Kind) {
switch current.Kind() {
case reflect.Ptr:
if current.IsNil() {
return current, reflect.Ptr
}
return ExtractType(current.Elem())
case reflect.Interface:
if current.IsNil() {
return current, reflect.Interface
}
return Extra... | go | {
"resource": ""
} |
q20289 | hasValue | train | func hasValue(field reflect.Value) bool {
switch field.Kind() {
case reflect.Slice, reflect.Map, reflect.Ptr, reflect.Interface, reflect.Chan, reflect.Func:
return !field.IsNil()
default:
return field.IsValid() && field.Interface() != reflect.Zero(field.Type()).Interface()
}
} | go | {
"resource": ""
} |
q20290 | New | train | func New() *Compiler {
compiler := new(Compiler)
compiler.filename = ""
compiler.tempvarIndex = 0
compiler.PrettyPrint = true
compiler.Options = DefaultOptions
compiler.mixins = make(map[string]*parser.Mixin)
return compiler
} | go | {
"resource": ""
} |
q20291 | MustCompile | train | func MustCompile(input string, options Options) *template.Template {
t, err := Compile(input, options)
if err != nil {
panic(err)
}
return t
} | go | {
"resource": ""
} |
q20292 | MustCompileFile | train | func MustCompileFile(filename string, options Options) *template.Template {
t, err := CompileFile(filename, options)
if err != nil {
panic(err)
}
return t
} | go | {
"resource": ""
} |
q20293 | MustCompileDir | train | func MustCompileDir(dirname string, dopt DirOptions, opt Options) map[string]*template.Template {
m, err := CompileDir(dirname, dopt, opt)
if err != nil {
panic(err)
}
return m
} | go | {
"resource": ""
} |
q20294 | ParseData | train | func (c *Compiler) ParseData(input []byte, filename string) (err error) {
defer func() {
if r := recover(); r != nil {
err = errors.New(r.(string))
}
}()
parser, err := parser.ByteParser(input)
parser.SetFilename(filename)
if c.VirtualFilesystem != nil {
parser.SetVirtualFilesystem(c.VirtualFilesystem)
... | go | {
"resource": ""
} |
q20295 | ParseFile | train | func (c *Compiler) ParseFile(filename string) (err error) {
defer func() {
if r := recover(); r != nil {
err = errors.New(r.(string))
}
}()
p, err := parser.FileParser(filename)
if err != nil && c.VirtualFilesystem != nil {
p, err = parser.VirtualFileParser(filename, c.VirtualFilesystem)
}
if err != nil... | go | {
"resource": ""
} |
q20296 | CompileWithName | train | func (c *Compiler) CompileWithName(name string) (*template.Template, error) {
return c.CompileWithTemplate(template.New(name))
} | go | {
"resource": ""
} |
q20297 | CompileWithTemplate | train | func (c *Compiler) CompileWithTemplate(t *template.Template) (*template.Template, error) {
data, err := c.CompileString()
if err != nil {
return nil, err
}
tpl, err := t.Funcs(FuncMap).Parse(data)
if err != nil {
return nil, err
}
return tpl, nil
} | go | {
"resource": ""
} |
q20298 | Next | train | func (s *scanner) Next() *token {
if s.readRaw {
s.readRaw = false
return s.NextRaw()
}
s.ensureBuffer()
if stashed := s.stash.Front(); stashed != nil {
tok := stashed.Value.(*token)
s.stash.Remove(stashed)
return tok
}
switch s.state {
case scnEOF:
if outdent := s.indentStack.Back(); outdent != n... | go | {
"resource": ""
} |
q20299 | ensureBuffer | train | func (s *scanner) ensureBuffer() {
if len(s.buffer) > 0 {
return
}
buf, err := s.reader.ReadString('\n')
if err != nil && err != io.EOF {
panic(err)
} else if err != nil && len(buf) == 0 {
s.state = scnEOF
} else {
// endline "LF only" or "\n" use Unix, Linux, modern MacOS X, FreeBSD, BeOS, RISC OS
if... | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.