id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1
value |
|---|---|---|
c11700 | err != nil {
return nil, err
}
return repo.parsePrettyFormatLogToList(stdout)
} | |
c11701 | err != nil {
return nil, err
}
tag, err := repo.getTag(id)
if err != nil {
return nil, err
}
tag.Name = name
return tag, nil
} | |
c11702 | err != nil {
return nil, err
}
tags := strings.Split(stdout, "\n")
tags = tags[:len(tags)-1]
if version.Compare(gitVersion, "2.4.9", "<") {
version.Sort(tags)
// Reverse order
for i := 0; i < len(tags)/2; i++ {
j := len(tags) - i - 1
tags[i], tags[j] = tags[j], tags[i]
}
}
return tags, nil
} | |
c11703 |
_, err := cmd.RunInDir(repo.Path)
return err
} | |
c11704 | == -1 {
return in
}
out := bytes.Replace(in, escapedSlash, regularSlash, -1)
out = bytes.Replace(out, escapedTab, regularTab, -1)
return out
} | |
c11705 | nil {
return nil, err
}
t.entries, err = parseTreeData(t, stdout)
return t.entries, err
} | |
c11706 | cmd.RunTimeout(opts.Timeout)
if err != nil {
return false
}
return true
} | |
c11707 |
cmd.AddArguments("--bare")
}
_, err := cmd.RunInDir(repoPath)
return err
} | |
c11708 | &Repository{
Path: repoPath,
commitCache: newObjectCache(),
tagCache: newObjectCache(),
}, nil
} | |
c11709 |
}
if len(opts.Branch) > 0 {
cmd.AddArguments("-b", opts.Branch)
}
cmd.AddArguments(from, to)
if opts.Timeout <= 0 {
opts.Timeout = -1
}
_, err = cmd.RunTimeout(opts.Timeout)
return err
} | |
c11710 |
cmd.AddArguments("--prune")
}
if opts.Timeout <= 0 {
opts.Timeout = -1
}
_, err := cmd.RunInDirTimeout(opts.Timeout, repoPath)
return err
} | |
c11711 | if opts.Timeout <= 0 {
opts.Timeout = -1
}
_, err := cmd.RunInDirTimeout(opts.Timeout, repoPath)
return err
} | |
c11712 | {
_, err := NewCommand("push", remote, branch).AddEnvs(envs...).RunInDir(repoPath)
return err
} | |
c11713 | PushWithEnvs(repoPath, remote, branch, nil)
} | |
c11714 | if opts.Timeout <= 0 {
opts.Timeout = -1
}
_, err := cmd.RunInDirTimeout(opts.Timeout, repoPath)
return err
} | |
c11715 |
_, err := cmd.AddArguments(revision).RunInDir(repoPath)
return err
} | |
c11716 | _, err := NewCommand("mv").AddArguments(oldTreeName, newTreeName).RunInDir(repoPath)
return err
} | |
c11717 | 1024
case strings.HasPrefix(line, _STAT_PRUNE_PACKABLE):
countObject.PrunePackable = com.StrTo(line[16:]).MustInt64()
case strings.HasPrefix(line, _STAT_GARBAGE):
countObject.Garbage = com.StrTo(line[9:]).MustInt64()
case strings.HasPrefix(line, _STAT_SIZE_GARBAGE):
countObject.SizeGarbage = com.StrTo(l... | |
c11718 | nil {
return
}
transport := getTransportLayer(httpClient, 0)
httpClient.Transport = transport
c.client = httpClient
}
} | |
c11719 | _, opt := range options {
opt(c)
}
if c.client == nil {
httpClient := &http.Client{}
UsingClient(httpClient)(c)
}
return c, nil
} | |
c11720 |
return resErr.ErrorCode == subjectNotFoundCode
}
return false
} | |
c11721 |
return resErr.ErrorCode == schemaNotFoundCode
}
return false
} | |
c11722 |
// GET /subjects/(string: subject)/versions
path := fmt.Sprintf(subjectPath, subject+"/versions")
resp, respErr := c.do(http.MethodGet, path, "", nil)
if respErr != nil {
err = respErr
return
}
err = c.readJSON(resp, &versions)
return
} | |
c11723 | // error?
return false, fs, err
}
if err = c.readJSON(resp, &fs); err != nil {
return true, fs, err // found but error when unmarshal.
}
// so we have a schema.
return true, fs, nil
} | |
c11724 |
return c.getSubjectSchemaAtVersion(subject, versionID)
} | |
c11725 | resp, respErr := c.do(http.MethodGet, path, "", nil)
if respErr != nil && respErr.(ResourceError).ErrorCode != 404 {
return config, respErr
}
if resp != nil {
err = c.readJSON(resp, &config)
}
return config, err
} | |
c11726 | versionID int) (bool, error) {
return c.isSchemaCompatibleAtVersion(subject, avroSchema, versionID)
} | |
c11727 | 64)
*i = Int64Value(v)
return err
} | |
c11728 | 64)
*i = UintValue(v)
return err
} | |
c11729 | = StringValue(val)
return nil
} | |
c11730 |
return nil
}
v, err := time.ParseDuration(s)
*d = Duration(v)
return err
} | |
c11731 | return d.Set(string(text))
} | |
c11732 | json.Marshal(time.Duration(*d))
} | |
c11733 |
var value string
err := json.Unmarshal(text, &value)
if err != nil {
return err
}
v, err := time.ParseDuration(value)
*d = Duration(v)
return err
} | |
c11734 | err := time.Parse(time.RFC3339, s)
*t = TimeValue(v)
return err
} | |
c11735 | == ',' || c == ';'
}
// get function
slice := strings.FieldsFunc(str, fargs)
*s = append(*s, slice...)
return nil
} | |
c11736 | }
if _, ok := flagMap[name]; ok {
return fmt.Errorf("tag already exists: %s", name)
}
flagMap[name] = objValue.Type().Field(i)
if err := getTypesRecursive(objValue.Field(i), flagMap, name); err != nil {
return err
}
}
}
case reflect.Ptr:
if len(key) > 0 {
field := flagMap[na... | |
c11737 | 0, len(flagMap))
for f, structField := range flagMap {
if structField.Type.Kind() == reflect.Bool {
flags = append(flags, f)
}
}
return flags, nil
} | |
c11738 | ""); err != nil {
return []string{}, err
}
flags := make([]string, 0, len(flagMap))
for f := range flagMap {
flags = append(flags, f)
}
return flags, nil
} | |
c11739 |
starNilPointersObjVal := nilPointersObjVal.Elem()
starNilPointersObjVal.Set(starObjValue)
for i := 0; i < nilPointersObjVal.Elem().NumField(); i++ {
if field := nilPointersObjVal.Elem().Field(i); field.Kind() == reflect.Ptr && field.CanSet() {
field.Set(reflect.Zero(field.Type()))
}
}
return nilPointersOb... | |
c11740 |
return fmt.Errorf("%s is not settable", fieldValue.Type().String())
}
return nil
} | |
c11741 |
return PrintHelpWithCommand(flagMap, defaultValmap, parsers, nil, nil)
} | |
c11742 | {
if err != flag.ErrHelp {
fmt.Printf("Error: %s\n", err)
}
if !strings.Contains(err.Error(), ":No parser for type") {
_ = PrintHelp(flagMap, defaultValmap, parsers)
}
return err
} | |
c11743 | string
SubCommands map[string]string
}
tempStruct := TempStruct{}
if cmd != nil {
tempStruct.ProgName = cmd.Name
tempStruct.ProgDescription = cmd.Description
tempStruct.SubCommands = map[string]string{}
if len(subCmd) > 1 && cmd == subCmd[0] {
for _, c := range subCmd[1:] {
if !c.HideHelp {
... | |
c11744 |
}
if errHelp := PrintHelpWithCommand(flagMap, defaultValMap, parsers, cmd, subCmd); errHelp != nil {
return errHelp
}
return err
} | |
c11745 | = []*Command{rootCommand}
f.args = args
f.customParsers = map[reflect.Type]parse.Parser{}
return &f
} | |
c11746 | append(f.commands, command)
} | |
c11747 | f.customParsers[typ] = parser
} | |
c11748 | err := f.Parse(f.calledCommand); err != nil {
return err
}
return f.calledCommand.Run()
} | |
c11749 | if err != nil {
return "", ""
}
return container.Config.Labels["HealthCheck"], container.Config.Labels["HealthCheckArgs"]
} | |
c11750 | if event == nil {
// This usually happens because of a Docker restart.
// Sleep, let us reconnect in the background, then loop.
return nil
}
log.Debugf("Event: %#v\n", event)
d.handleEvent(*event)
case <-time.After(d.sleepInterval):
d.getContainers()
case <-time.After(CacheDrainInt... | |
c11751 | i, svc := range d.services {
svcList[i] = *svc
}
return svcList
} | |
c11752 | listener := d.listenerForContainer(container)
if listener != nil {
listeners = append(listeners, *listener)
}
}
return listeners
} | |
c11753 |
if len(id) > 12 {
id = id[:12]
}
svc := d.findServiceByID(id)
if svc == nil {
return nil
}
listenPort := portForServicePort(svc, svcPortStr, "tcp") // We only do HTTP (TCP)
// -1 is returned when there is no match
if listenPort == nil {
log.Warnf(
"SidecarListener label found on %s, but no matching ... | |
c11754 |
if err != nil {
log.Warnf(
"SidecarListener label found on %s, can't decode port '%s'",
svc.ID, portStr,
)
return nil
}
for _, port := range svc.Ports {
if port.ServicePort == svcPort && port.Type == pType {
return &port
}
}
return nil
} | |
c11755 | one for GC
c.cache = make(map[string]*docker.Container, newSize)
} | |
c11756 | defer c.Unlock()
for id := range c.cache {
if _, ok := liveContainers[id]; !ok {
delete(c.cache, id)
}
}
} | |
c11757 | c.cache[svcID]; ok {
return container
}
return nil
} | |
c11758 | {
if healthCheck, healthCheckArgs := disco.HealthCheck(svc); healthCheck != "" {
return healthCheck, healthCheckArgs
}
}
return "", ""
} | |
c11759 |
if len(services) > 0 {
aggregate = append(aggregate, services...)
}
}
return aggregate
} | |
c11760 | if oldStatus == service.ALIVE {
return true
}
default:
log.Errorf("Got unknown service change status: %d", newStatus)
return false
}
log.Debugf("Skipped HAproxy update due to state machine check")
return false
} | |
c11761 | resp.StatusCode)
}
bytes, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
state, err := catalog.Decode(bytes)
if err != nil {
return nil, err
}
return state, nil
} | |
c11762 | := range rcvr.Subscriptions {
if subName == svcName {
return true
}
}
return false
} | |
c11763 |
rcvr.Subscriptions = append(rcvr.Subscriptions, svcName)
} | |
c11764 | for i := 0; i < pending; i++ {
reload = <-rcvr.ReloadChan
}
if pending > 0 {
log.Infof("Skipped %d messages between %s and %s", pending, first, reload)
}
// Don't notify more frequently than every RELOAD_HOLD_DOWN period. When a
// deployment rolls across the cluster it can trigger a bunch of groupa... | |
c11765 | log.Info("Successfully retrieved state")
rcvr.CurrentState = state
if rcvr.OnUpdate == nil {
log.Error("OnUpdate() callback not defined!")
} else {
rcvr.OnUpdate(state)
}
}
return nil
} | |
c11766 | if len(*opts.Discover) > 0 {
config.Sidecar.Discovery = *opts.Discover
}
if len(*opts.LoggingLevel) > 0 {
config.Sidecar.LoggingLevel = *opts.LoggingLevel
}
} | |
c11767 |
delegate.Metadata = NodeMetadata{
ClusterName: config.Sidecar.ClusterName,
State: "Running",
}
delegate.Start()
return delegate
} | |
c11768 | if requested
if *opts.CpuProfile {
profilerFile, err := os.Create("sidecar.cpu.prof")
exitWithError(err, "Can't write profiling file")
pprof.StartCPUProfile(profilerFile)
log.Debug("Profiling!")
}
} | |
c11769 | verbose timestamping
log.SetFormatter(&log.TextFormatter{FullTimestamp: true})
}
} | |
c11770 | catalog.NewUrlListener(url, false)
listener.Watch(state)
}
} | |
c11771 | 5),
LastUpdated: time.Unix(0, 0),
LastChanged: time.Unix(0, 0),
}
return server
} | |
c11772 |
tombstoneRetransmit: TOMBSTONE_RETRANSMIT,
ServiceMsgs: make(chan service.Service, 25),
listeners: make(map[string]Listener),
}
state.Hostname, err = os.Hostname()
if err != nil {
log.Errorf("Error getting hostname! %s", err.Error())
}
return state
} | |
c11773 | service := <-state.ServiceMsgs
state.AddServiceEntry(service)
return nil
})
} | |
c11774 | string) bool {
_, ok := state.Servers[hostname]
return ok
} | |
c11775 | := svc.Status
state.ServiceChanged(svc, previousStatus, svc.Updated)
svc.Tombstone()
tombstones = append(tombstones, *svc)
}
if len(tombstones) < 1 {
log.Warn("Tried to announce a zero length list of tombstones")
return
}
state.SendServices(
tombstones,
director.NewTimedLooper(TOMBSTONE_COUNT, stat... | |
c11776 | updated)
state.NotifyListeners(svc, previousStatus, state.LastChanged)
} | |
c11777 | }
state.Lock()
defer state.Unlock()
state.listeners[listener.Name()] = listener
log.Debugf("AddListener(): added %s, new count %d", listener.Name(), len(state.listeners))
} | |
c11778 | %s, new count %d", name, len(state.listeners))
return nil
}
return fmt.Errorf("No listener found with the name: %s", name)
} | |
c11779 | listeners = append(listeners, listener)
}
state.RUnlock()
return listeners
} | |
c11780 | } else if newSvc.Invalidates(server.Services[newSvc.ID]) {
// We have to set these even if the status did not change
server.LastUpdated = newSvc.Updated
// Store the previous newSvc so we can compare it
oldEntry := server.Services[newSvc.ID]
// Update the new one
server.Services[newSvc.ID] = &newSvc
/... | |
c11781 | := range server.Services {
state.ServiceMsgs <- *service
}
}
} | |
c11782 | svc.Encode()
if err != nil {
log.Errorf("ERROR encoding message to forward: (%s)", err.Error())
return
}
state.Broadcasts <- [][]byte{encoded}
}()
} | |
c11783 | log.Println(state.Format(list))
} | |
c11784 | container := range fn() {
state.ServiceMsgs <- container
}
return nil
})
} | |
c11785 | if ok {
urlListener.Watch(state)
} else {
state.AddListener(listener)
}
}
}
// Remove old ones
listeners := state.listeners
for _, listener := range listeners {
if listener.Managed() && !containsListener(discovered, listener.Name()) {
log.Infof("Removing listener %s because the ser... | |
c11786 |
if found == nil || (!svc.IsTombstone() && svc.Status != found.Status) {
return true
}
return false
} | |
c11787 | Figure out how many times to announce the service. New services get more announcements.
runCount := 1
if haveNewServices {
runCount = ALIVE_COUNT
}
lastTime = time.Now().UTC()
state.SendServices(
services,
director.NewTimedLooper(runCount, state.tombstoneRetransmit, nil),
)
log.Debug(... | |
c11788 | err.Error())
}
prepared = append(prepared, encoded)
}
// We add time to make sure that these get retransmitted by peers.
// Otherwise they aren't "new" messages and don't get retransmitted.
additionalTime = additionalTime + 50*time.Nanosecond
state.Broadcasts <- prepared // Put it on the wire
... | |
c11789 | svc *service.Service) {
serviceMap[svc.Name] = append(serviceMap[svc.Name], svc)
},
)
return serviceMap
} | |
c11790 | log.Errorf("Error decoding state! (%s)", err.Error())
}
return newState, err
} | |
c11791 | HAproxy{
ReloadCmd: reloadCmd,
VerifyCmd: verifyCmd,
Template: "views/haproxy.cfg",
ConfigFile: configFile,
PidFile: pidFile,
}
return &proxy
} | |
c11792 | return replace.ReplaceAllString(image, "-")
} | |
c11793 | _, port := range svc.Ports {
if port.ServicePort == matchPort {
internalPort := strconv.FormatInt(port.Port, 10)
return internalPort
}
}
return "-1"
} | |
c11794 | return port.IP
}
}
// This defaults to the previous behavior of templating the hostname
// instead of the IP address. This relies on haproxy being able to
// resolve the hostname (which means non-FQDN hostnames are a hazard).
// Ideally this never happens for clusters that have IP addresses defined.
return sv... | |
c11795 |
go func() {
for {
select {
case <-sigChan:
// swallow signal
case <-h.sigStopChan:
break
}
}
}()
signal.Notify(sigChan, syscall.SIGSTOP, syscall.SIGTSTP, syscall.SIGTTIN, syscall.SIGTTOU)
} | |
c11796 | syscall.SIGTTIN, syscall.SIGTTOU)
select {
case h.sigStopChan <- struct{}{}: // nothing
default:
}
h.sigLock.Unlock()
} | |
c11797 | only run _one_
// command at a time. This is totally fine for HAproxy.
h.sigLock.Lock()
defer h.sigLock.Unlock()
if !h.signalsHandled {
log.Info("Setting up signal handlers")
h.swallowSignals()
h.signalsHandled = true
}
err := cmd.Run()
if err != nil {
err = fmt.Errorf("Error running '%s': %s\n%s\n%s... | |
c11798 | }
if err := h.WriteConfig(state, outfile); err != nil {
return err
}
if err = h.Verify(); err != nil {
return fmt.Errorf("Failed to verify HAproxy config! (%s)", err.Error())
}
return h.Reload()
} | |
c11799 | rcvr.CurrentState = &evt.State
rcvr.LastSvcChanged = &evt.ChangeEvent.Service
if ShouldNotify(evt.ChangeEvent.PreviousStatus, evt.ChangeEvent.Service.Status) {
if !rcvr.IsSubscribed(evt.ChangeEvent.Service.Name) {
return
}
if rcvr.OnUpdate == nil {
log.Errorf("No OnUpdate() callback registered!... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.