_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q11700 | CommitsAfterDate | train | func (repo *Repository) CommitsAfterDate(date string) (*list.List, error) {
stdout, err := NewCommand("log", _PRETTY_LOG_FORMAT, "--since="+date).RunInDirBytes(repo.Path)
if err != nil {
return nil, err
}
return repo.parsePrettyFormatLogToList(stdout)
} | go | {
"resource": ""
} |
q11701 | GetTag | train | func (repo *Repository) GetTag(name string) (*Tag, error) {
stdout, err := NewCommand("show-ref", "--tags", name).RunInDir(repo.Path)
if err != nil {
return nil, err
}
id, err := NewIDFromString(strings.Split(stdout, " ")[0])
if err != nil {
return nil, err
}
tag, err := repo.getTag(id)
if err != nil {
... | go | {
"resource": ""
} |
q11702 | GetTags | train | func (repo *Repository) GetTags() ([]string, error) {
cmd := NewCommand("tag", "-l")
if version.Compare(gitVersion, "2.4.9", ">=") {
cmd.AddArguments("--sort=-creatordate")
}
stdout, err := cmd.RunInDir(repo.Path)
if err != nil {
return nil, err
}
tags := strings.Split(stdout, "\n")
tags = tags[:len(tags)... | go | {
"resource": ""
} |
q11703 | DeleteTag | train | func (repo *Repository) DeleteTag(name string) error {
cmd := NewCommand("tag", "-d")
cmd.AddArguments(name)
_, err := cmd.RunInDir(repo.Path)
return err
} | go | {
"resource": ""
} |
q11704 | UnescapeChars | train | func UnescapeChars(in []byte) []byte {
// LEGACY [Go 1.7]: use more expressive bytes.ContainsAny
if bytes.IndexAny(in, "\\\t") == -1 {
return in
}
out := bytes.Replace(in, escapedSlash, regularSlash, -1)
out = bytes.Replace(out, escapedTab, regularTab, -1)
return out
} | go | {
"resource": ""
} |
q11705 | ListEntries | train | func (t *Tree) ListEntries() (Entries, error) {
if t.entriesParsed {
return t.entries, nil
}
t.entriesParsed = true
stdout, err := NewCommand("ls-tree", t.ID.String()).RunInDirBytes(t.repo.Path)
if err != nil {
return nil, err
}
t.entries, err = parseTreeData(t, stdout)
return t.entries, err
} | go | {
"resource": ""
} |
q11706 | IsRepoURLAccessible | train | func IsRepoURLAccessible(opts NetworkOptions) bool {
cmd := NewCommand("ls-remote", "-q", "-h", opts.URL, "HEAD")
if opts.Timeout <= 0 {
opts.Timeout = -1
}
_, err := cmd.RunTimeout(opts.Timeout)
if err != nil {
return false
}
return true
} | go | {
"resource": ""
} |
q11707 | InitRepository | train | func InitRepository(repoPath string, bare bool) error {
os.MkdirAll(repoPath, os.ModePerm)
cmd := NewCommand("init")
if bare {
cmd.AddArguments("--bare")
}
_, err := cmd.RunInDir(repoPath)
return err
} | go | {
"resource": ""
} |
q11708 | OpenRepository | train | func OpenRepository(repoPath string) (*Repository, error) {
repoPath, err := filepath.Abs(repoPath)
if err != nil {
return nil, err
} else if !isDir(repoPath) {
return nil, errors.New("no such file or directory")
}
return &Repository{
Path: repoPath,
commitCache: newObjectCache(),
tagCache: ne... | go | {
"resource": ""
} |
q11709 | Clone | train | func Clone(from, to string, opts CloneRepoOptions) (err error) {
toDir := path.Dir(to)
if err = os.MkdirAll(toDir, os.ModePerm); err != nil {
return err
}
cmd := NewCommand("clone")
if opts.Mirror {
cmd.AddArguments("--mirror")
}
if opts.Bare {
cmd.AddArguments("--bare")
}
if opts.Quiet {
cmd.AddArgum... | go | {
"resource": ""
} |
q11710 | Fetch | train | func Fetch(repoPath string, opts FetchRemoteOptions) error {
cmd := NewCommand("fetch")
if opts.Prune {
cmd.AddArguments("--prune")
}
if opts.Timeout <= 0 {
opts.Timeout = -1
}
_, err := cmd.RunInDirTimeout(opts.Timeout, repoPath)
return err
} | go | {
"resource": ""
} |
q11711 | Pull | train | func Pull(repoPath string, opts PullRemoteOptions) error {
cmd := NewCommand("pull")
if opts.Rebase {
cmd.AddArguments("--rebase")
}
if opts.All {
cmd.AddArguments("--all")
} else {
cmd.AddArguments(opts.Remote)
cmd.AddArguments(opts.Branch)
}
if opts.Timeout <= 0 {
opts.Timeout = -1
}
_, err := cmd... | go | {
"resource": ""
} |
q11712 | PushWithEnvs | train | func PushWithEnvs(repoPath, remote, branch string, envs []string) error {
_, err := NewCommand("push", remote, branch).AddEnvs(envs...).RunInDir(repoPath)
return err
} | go | {
"resource": ""
} |
q11713 | Push | train | func Push(repoPath, remote, branch string) error {
return PushWithEnvs(repoPath, remote, branch, nil)
} | go | {
"resource": ""
} |
q11714 | Checkout | train | func Checkout(repoPath string, opts CheckoutOptions) error {
cmd := NewCommand("checkout")
if len(opts.OldBranch) > 0 {
cmd.AddArguments("-b")
}
cmd.AddArguments(opts.Branch)
if len(opts.OldBranch) > 0 {
cmd.AddArguments(opts.OldBranch)
}
if opts.Timeout <= 0 {
opts.Timeout = -1
}
_, err := cmd.RunInDi... | go | {
"resource": ""
} |
q11715 | ResetHEAD | train | func ResetHEAD(repoPath string, hard bool, revision string) error {
cmd := NewCommand("reset")
if hard {
cmd.AddArguments("--hard")
}
_, err := cmd.AddArguments(revision).RunInDir(repoPath)
return err
} | go | {
"resource": ""
} |
q11716 | MoveFile | train | func MoveFile(repoPath, oldTreeName, newTreeName string) error {
_, err := NewCommand("mv").AddArguments(oldTreeName, newTreeName).RunInDir(repoPath)
return err
} | go | {
"resource": ""
} |
q11717 | GetRepoSize | train | func GetRepoSize(repoPath string) (*CountObject, error) {
cmd := NewCommand("count-objects", "-v")
stdout, err := cmd.RunInDir(repoPath)
if err != nil {
return nil, err
}
countObject := new(CountObject)
for _, line := range strings.Split(stdout, "\n") {
switch {
case strings.HasPrefix(line, _STAT_COUNT):
... | go | {
"resource": ""
} |
q11718 | UsingClient | train | func UsingClient(httpClient *http.Client) Option {
return func(c *Client) {
if httpClient == nil {
return
}
transport := getTransportLayer(httpClient, 0)
httpClient.Transport = transport
c.client = httpClient
}
} | go | {
"resource": ""
} |
q11719 | NewClient | train | func NewClient(baseURL string, options ...Option) (*Client, error) {
baseURL = formatBaseURL(baseURL)
if _, err := url.Parse(baseURL); err != nil {
return nil, err
}
c := &Client{baseURL: baseURL}
for _, opt := range options {
opt(c)
}
if c.client == nil {
httpClient := &http.Client{}
UsingClient(httpC... | go | {
"resource": ""
} |
q11720 | IsSubjectNotFound | train | func IsSubjectNotFound(err error) bool {
if err == nil {
return false
}
if resErr, ok := err.(ResourceError); ok {
return resErr.ErrorCode == subjectNotFoundCode
}
return false
} | go | {
"resource": ""
} |
q11721 | IsSchemaNotFound | train | func IsSchemaNotFound(err error) bool {
if err == nil {
return false
}
if resErr, ok := err.(ResourceError); ok {
return resErr.ErrorCode == schemaNotFoundCode
}
return false
} | go | {
"resource": ""
} |
q11722 | Versions | train | func (c *Client) Versions(subject string) (versions []int, err error) {
if subject == "" {
err = errRequired("subject")
return
}
// # List all versions of a particular subject
// GET /subjects/(string: subject)/versions
path := fmt.Sprintf(subjectPath, subject+"/versions")
resp, respErr := c.do(http.MethodGe... | go | {
"resource": ""
} |
q11723 | IsRegistered | train | func (c *Client) IsRegistered(subject, schema string) (bool, Schema, error) {
var fs Schema
sc := schemaOnlyJSON{schema}
send, err := json.Marshal(sc)
if err != nil {
return false, fs, err
}
path := fmt.Sprintf(subjectPath, subject)
resp, err := c.do(http.MethodPost, path, "", send)
if err != nil {
// sch... | go | {
"resource": ""
} |
q11724 | GetSchemaBySubject | train | func (c *Client) GetSchemaBySubject(subject string, versionID int) (Schema, error) {
return c.getSubjectSchemaAtVersion(subject, versionID)
} | go | {
"resource": ""
} |
q11725 | getConfigSubject | train | func (c *Client) getConfigSubject(subject string) (Config, error) {
var err error
var config = Config{}
path := fmt.Sprintf("/config/%s", subject)
resp, respErr := c.do(http.MethodGet, path, "", nil)
if respErr != nil && respErr.(ResourceError).ErrorCode != 404 {
return config, respErr
}
if resp != nil {
er... | go | {
"resource": ""
} |
q11726 | IsSchemaCompatible | train | func (c *Client) IsSchemaCompatible(subject string, avroSchema string, versionID int) (bool, error) {
return c.isSchemaCompatibleAtVersion(subject, avroSchema, versionID)
} | go | {
"resource": ""
} |
q11727 | Set | train | func (i *Int64Value) Set(s string) error {
v, err := strconv.ParseInt(s, 0, 64)
*i = Int64Value(v)
return err
} | go | {
"resource": ""
} |
q11728 | Set | train | func (i *UintValue) Set(s string) error {
v, err := strconv.ParseUint(s, 0, 64)
*i = UintValue(v)
return err
} | go | {
"resource": ""
} |
q11729 | Set | train | func (s *StringValue) Set(val string) error {
*s = StringValue(val)
return nil
} | go | {
"resource": ""
} |
q11730 | Set | train | func (d *Duration) Set(s string) error {
if v, err := strconv.ParseInt(s, 10, 64); err == nil {
*d = Duration(time.Duration(v) * time.Second)
return nil
}
v, err := time.ParseDuration(s)
*d = Duration(v)
return err
} | go | {
"resource": ""
} |
q11731 | UnmarshalText | train | func (d *Duration) UnmarshalText(text []byte) error {
return d.Set(string(text))
} | go | {
"resource": ""
} |
q11732 | MarshalJSON | train | func (d *Duration) MarshalJSON() ([]byte, error) {
return json.Marshal(time.Duration(*d))
} | go | {
"resource": ""
} |
q11733 | UnmarshalJSON | train | func (d *Duration) UnmarshalJSON(text []byte) error {
if v, err := strconv.ParseInt(string(text), 10, 64); err == nil {
*d = Duration(time.Duration(v))
return nil
}
// We use json unmarshal on value because we have the quoted version
var value string
err := json.Unmarshal(text, &value)
if err != nil {
retu... | go | {
"resource": ""
} |
q11734 | Set | train | func (t *TimeValue) Set(s string) error {
v, err := time.Parse(time.RFC3339, s)
*t = TimeValue(v)
return err
} | go | {
"resource": ""
} |
q11735 | Set | train | func (s *SliceStrings) Set(str string) error {
fargs := func(c rune) bool {
return c == ',' || c == ';'
}
// get function
slice := strings.FieldsFunc(str, fargs)
*s = append(*s, slice...)
return nil
} | go | {
"resource": ""
} |
q11736 | getTypesRecursive | train | func getTypesRecursive(objValue reflect.Value, flagMap map[string]reflect.StructField, key string) error {
name := key
switch objValue.Kind() {
case reflect.Struct:
for i := 0; i < objValue.NumField(); i++ {
if objValue.Type().Field(i).Anonymous {
if err := getTypesRecursive(objValue.Field(i), flagMap, name... | go | {
"resource": ""
} |
q11737 | GetBoolFlags | train | func GetBoolFlags(config interface{}) ([]string, error) {
flagMap := make(map[string]reflect.StructField)
if err := getTypesRecursive(reflect.ValueOf(config), flagMap, ""); err != nil {
return []string{}, err
}
flags := make([]string, 0, len(flagMap))
for f, structField := range flagMap {
if structField.Type.... | go | {
"resource": ""
} |
q11738 | GetFlags | train | func GetFlags(config interface{}) ([]string, error) {
flagMap := make(map[string]reflect.StructField)
if err := getTypesRecursive(reflect.ValueOf(config), flagMap, ""); err != nil {
return []string{}, err
}
flags := make([]string, 0, len(flagMap))
for f := range flagMap {
flags = append(flags, f)
}
return f... | go | {
"resource": ""
} |
q11739 | setPointersNil | train | func setPointersNil(objValue reflect.Value) (reflect.Value, error) {
switch {
case objValue.Kind() != reflect.Ptr:
return objValue, fmt.Errorf("parameters objValue must be a not-nil pointer on a struct, not a %s", objValue.Kind())
case objValue.IsNil():
return objValue, errors.New("parameters objValue must be a ... | go | {
"resource": ""
} |
q11740 | setFields | train | func setFields(fieldValue reflect.Value, val parse.Parser) error {
if fieldValue.CanSet() {
fieldValue.Set(reflect.ValueOf(val).Elem().Convert(fieldValue.Type()))
} else {
return fmt.Errorf("%s is not settable", fieldValue.Type().String())
}
return nil
} | go | {
"resource": ""
} |
q11741 | PrintHelp | train | func PrintHelp(flagMap map[string]reflect.StructField, defaultValmap map[string]reflect.Value, parsers map[reflect.Type]parse.Parser) error {
return PrintHelpWithCommand(flagMap, defaultValmap, parsers, nil, nil)
} | go | {
"resource": ""
} |
q11742 | PrintError | train | func PrintError(err error, flagMap map[string]reflect.StructField, defaultValmap map[string]reflect.Value, parsers map[reflect.Type]parse.Parser) error {
if err != flag.ErrHelp {
fmt.Printf("Error: %s\n", err)
}
if !strings.Contains(err.Error(), ":No parser for type") {
_ = PrintHelp(flagMap, defaultValmap, pars... | go | {
"resource": ""
} |
q11743 | PrintHelpWithCommand | train | func PrintHelpWithCommand(flagMap map[string]reflect.StructField, defaultValMap map[string]reflect.Value, parsers map[reflect.Type]parse.Parser, cmd *Command, subCmd []*Command) error {
// Hide command from help
if cmd != nil && cmd.HideHelp {
return fmt.Errorf("command %s not found", cmd.Name)
}
// Define a tem... | go | {
"resource": ""
} |
q11744 | PrintErrorWithCommand | train | func PrintErrorWithCommand(err error, flagMap map[string]reflect.StructField, defaultValMap map[string]reflect.Value, parsers map[reflect.Type]parse.Parser, cmd *Command, subCmd []*Command) error {
if err != flag.ErrHelp {
fmt.Printf("Error here : %s\n", err)
}
if errHelp := PrintHelpWithCommand(flagMap, defaultV... | go | {
"resource": ""
} |
q11745 | New | train | func New(rootCommand *Command, args []string) *Flaeg {
var f Flaeg
f.commands = []*Command{rootCommand}
f.args = args
f.customParsers = map[reflect.Type]parse.Parser{}
return &f
} | go | {
"resource": ""
} |
q11746 | AddCommand | train | func (f *Flaeg) AddCommand(command *Command) {
f.commands = append(f.commands, command)
} | go | {
"resource": ""
} |
q11747 | AddParser | train | func (f *Flaeg) AddParser(typ reflect.Type, parser parse.Parser) {
f.customParsers[typ] = parser
} | go | {
"resource": ""
} |
q11748 | Run | train | func (f *Flaeg) Run() error {
if f.calledCommand == nil {
if _, _, err := f.findCommandWithCommandArgs(); err != nil {
return err
}
}
if _, err := f.Parse(f.calledCommand); err != nil {
return err
}
return f.calledCommand.Run()
} | go | {
"resource": ""
} |
q11749 | HealthCheck | train | func (d *DockerDiscovery) HealthCheck(svc *service.Service) (string, string) {
container, err := d.inspectContainer(svc)
if err != nil {
return "", ""
}
return container.Config.Labels["HealthCheck"], container.Config.Labels["HealthCheckArgs"]
} | go | {
"resource": ""
} |
q11750 | Run | train | func (d *DockerDiscovery) Run(looper director.Looper) {
connQuitChan := make(chan bool)
go d.manageConnection(connQuitChan)
go func() {
// Loop around, process any events which came in, and
// periodically fetch the whole container list
looper.Loop(func() error {
select {
case event := <-d.events:
... | go | {
"resource": ""
} |
q11751 | Services | train | func (d *DockerDiscovery) Services() []service.Service {
d.RLock()
defer d.RUnlock()
svcList := make([]service.Service, len(d.services))
for i, svc := range d.services {
svcList[i] = *svc
}
return svcList
} | go | {
"resource": ""
} |
q11752 | Listeners | train | func (d *DockerDiscovery) Listeners() []ChangeListener {
var listeners []ChangeListener
for _, cntnr := range d.services {
container, err := d.inspectContainer(cntnr)
if err != nil {
continue
}
listener := d.listenerForContainer(container)
if listener != nil {
listeners = append(listeners, *listener... | go | {
"resource": ""
} |
q11753 | listenerForContainer | train | func (d *DockerDiscovery) listenerForContainer(cntnr *docker.Container) *ChangeListener {
// See if the container has the SidecarListener label, which
// will tell us the ServicePort of the port that should be
// subscribed to Sidecar events.
svcPortStr, ok := cntnr.Config.Labels["SidecarListener"]
if !ok {
retu... | go | {
"resource": ""
} |
q11754 | portForServicePort | train | func portForServicePort(svc *service.Service, portStr string, pType string) *service.Port {
// Look up the ServicePort and translate to Docker port
svcPort, err := strconv.ParseInt(portStr, 10, 64)
if err != nil {
log.Warnf(
"SidecarListener label found on %s, can't decode port '%s'",
svc.ID, portStr,
)
... | go | {
"resource": ""
} |
q11755 | Drain | train | func (c *ContainerCache) Drain(newSize int) {
c.Lock()
defer c.Unlock()
// Make a new one, leave the old one for GC
c.cache = make(map[string]*docker.Container, newSize)
} | go | {
"resource": ""
} |
q11756 | Prune | train | func (c *ContainerCache) Prune(liveContainers map[string]interface{}) {
c.Lock()
defer c.Unlock()
for id := range c.cache {
if _, ok := liveContainers[id]; !ok {
delete(c.cache, id)
}
}
} | go | {
"resource": ""
} |
q11757 | Get | train | func (c *ContainerCache) Get(svcID string) *docker.Container {
c.RLock()
defer c.RUnlock()
if container, ok := c.cache[svcID]; ok {
return container
}
return nil
} | go | {
"resource": ""
} |
q11758 | HealthCheck | train | func (d *MultiDiscovery) HealthCheck(svc *service.Service) (string, string) {
for _, disco := range d.Discoverers {
if healthCheck, healthCheckArgs := disco.HealthCheck(svc); healthCheck != "" {
return healthCheck, healthCheckArgs
}
}
return "", ""
} | go | {
"resource": ""
} |
q11759 | Services | train | func (d *MultiDiscovery) Services() []service.Service {
var aggregate []service.Service
for _, disco := range d.Discoverers {
services := disco.Services()
if len(services) > 0 {
aggregate = append(aggregate, services...)
}
}
return aggregate
} | go | {
"resource": ""
} |
q11760 | ShouldNotify | train | func ShouldNotify(oldStatus int, newStatus int) bool {
log.Debugf("Checking event. OldStatus: %s NewStatus: %s",
service.StatusString(oldStatus), service.StatusString(newStatus),
)
// Compare old and new states to find significant changes only
switch newStatus {
case service.ALIVE:
return true
case service.T... | go | {
"resource": ""
} |
q11761 | FetchState | train | func FetchState(url string) (*catalog.ServicesState, error) {
client := &http.Client{Timeout: 5 * time.Second}
resp, err := client.Get(url)
if err != nil {
return nil, err
}
if resp.StatusCode < 200 || resp.StatusCode > 299 {
return nil, fmt.Errorf("Bad status code on state fetch: %d", resp.StatusCode)
}
b... | go | {
"resource": ""
} |
q11762 | IsSubscribed | train | func (rcvr *Receiver) IsSubscribed(svcName string) bool {
// If we didn't specify any specifically, then we want them all
if len(rcvr.Subscriptions) < 1 {
return true
}
for _, subName := range rcvr.Subscriptions {
if subName == svcName {
return true
}
}
return false
} | go | {
"resource": ""
} |
q11763 | Subscribe | train | func (rcvr *Receiver) Subscribe(svcName string) {
for _, subName := range rcvr.Subscriptions {
if subName == svcName {
return
}
}
rcvr.Subscriptions = append(rcvr.Subscriptions, svcName)
} | go | {
"resource": ""
} |
q11764 | ProcessUpdates | train | func (rcvr *Receiver) ProcessUpdates() {
if rcvr.Looper == nil {
log.Error("Unable to ProcessUpdates(), Looper is nil in receiver!")
return
}
rcvr.Looper.Loop(func() error {
// Batch up to RELOAD_BUFFER number updates into a
// single update.
first := <-rcvr.ReloadChan
pending := len(rcvr.ReloadChan)
... | go | {
"resource": ""
} |
q11765 | FetchInitialState | train | func (rcvr *Receiver) FetchInitialState(stateUrl string) error {
rcvr.StateLock.Lock()
defer rcvr.StateLock.Unlock()
log.Info("Fetching initial state on startup...")
state, err := FetchState(stateUrl)
if err != nil {
return err
} else {
log.Info("Successfully retrieved state")
rcvr.CurrentState = state
i... | go | {
"resource": ""
} |
q11766 | configureOverrides | train | func configureOverrides(config *Config, opts *CliOpts) {
if len(*opts.AdvertiseIP) > 0 {
config.Sidecar.AdvertiseIP = *opts.AdvertiseIP
}
if len(*opts.ClusterIPs) > 0 {
config.Sidecar.Seeds = *opts.ClusterIPs
}
if len(*opts.ClusterName) > 0 {
config.Sidecar.ClusterName = *opts.ClusterName
}
if len(*opts.Di... | go | {
"resource": ""
} |
q11767 | configureDelegate | train | func configureDelegate(state *catalog.ServicesState, config *Config) *servicesDelegate {
delegate := NewServicesDelegate(state)
delegate.Metadata = NodeMetadata{
ClusterName: config.Sidecar.ClusterName,
State: "Running",
}
delegate.Start()
return delegate
} | go | {
"resource": ""
} |
q11768 | configureCpuProfiler | train | func configureCpuProfiler(opts *CliOpts) {
if !*opts.CpuProfile {
return
}
var profilerFile os.File
// Capture CTRL-C and stop the CPU profiler
sigChannel := make(chan os.Signal, 1)
signal.Notify(sigChannel, os.Interrupt)
go func() {
for sig := range sigChannel {
log.Printf("Captured %v, stopping profil... | go | {
"resource": ""
} |
q11769 | configureLoggingFormat | train | func configureLoggingFormat(config *Config) {
if config.Sidecar.LoggingFormat == "json" {
log.SetFormatter(&log.JSONFormatter{})
} else {
// Default to verbose timestamping
log.SetFormatter(&log.TextFormatter{FullTimestamp: true})
}
} | go | {
"resource": ""
} |
q11770 | configureListeners | train | func configureListeners(config *Config, state *catalog.ServicesState) {
for _, url := range config.Listeners.Urls {
listener := catalog.NewUrlListener(url, false)
listener.Watch(state)
}
} | go | {
"resource": ""
} |
q11771 | NewServer | train | func NewServer(name string) *Server {
server := &Server{
Name: name,
// Pre-create for 5 services per host
Services: make(map[string]*service.Service, 5),
LastUpdated: time.Unix(0, 0),
LastChanged: time.Unix(0, 0),
}
return server
} | go | {
"resource": ""
} |
q11772 | NewServicesState | train | func NewServicesState() *ServicesState {
var err error
state := &ServicesState{
Servers: make(map[string]*Server, 5),
Broadcasts: make(chan [][]byte),
LastChanged: time.Unix(0, 0),
tombstoneRetransmit: TOMBSTONE_RETRANSMIT,
ServiceMsgs: make(chan service.Service, 25),
... | go | {
"resource": ""
} |
q11773 | ProcessServiceMsgs | train | func (state *ServicesState) ProcessServiceMsgs(looper director.Looper) {
looper.Loop(func() error {
service := <-state.ServiceMsgs
state.AddServiceEntry(service)
return nil
})
} | go | {
"resource": ""
} |
q11774 | HasServer | train | func (state *ServicesState) HasServer(hostname string) bool {
_, ok := state.Servers[hostname]
return ok
} | go | {
"resource": ""
} |
q11775 | ExpireServer | train | func (state *ServicesState) ExpireServer(hostname string) {
if !state.HasServer(hostname) || len(state.Servers[hostname].Services) == 0 {
log.Infof("No records to expire for %s", hostname)
return
}
hasLiveServices := false
for _, svc := range state.Servers[hostname].Services {
if !svc.IsTombstone() {
hasL... | go | {
"resource": ""
} |
q11776 | ServiceChanged | train | func (state *ServicesState) ServiceChanged(svc *service.Service, previousStatus int, updated time.Time) {
state.serverChanged(svc.Hostname, updated)
state.NotifyListeners(svc, previousStatus, state.LastChanged)
} | go | {
"resource": ""
} |
q11777 | AddListener | train | func (state *ServicesState) AddListener(listener Listener) {
if listener.Chan() == nil {
log.Errorf("Refusing to add listener %s with nil channel!", listener.Name())
return
}
if cap(listener.Chan()) < 1 {
log.Errorf("Refusing to add blocking channel as listener: %s", listener.Name())
return
}
state.Lock()... | go | {
"resource": ""
} |
q11778 | RemoveListener | train | func (state *ServicesState) RemoveListener(name string) error {
state.Lock()
defer state.Unlock()
if _, ok := state.listeners[name]; ok {
delete(state.listeners, name)
log.Debugf("RemoveListener(): removed %s, new count %d", name, len(state.listeners))
return nil
}
return fmt.Errorf("No listener found with... | go | {
"resource": ""
} |
q11779 | GetListeners | train | func (state *ServicesState) GetListeners() []Listener {
state.RLock()
var listeners []Listener
for _, listener := range state.listeners {
listeners = append(listeners, listener)
}
state.RUnlock()
return listeners
} | go | {
"resource": ""
} |
q11780 | AddServiceEntry | train | func (state *ServicesState) AddServiceEntry(newSvc service.Service) {
defer metrics.MeasureSince([]string{"services_state", "AddServiceEntry"}, time.Now())
state.Lock()
defer state.Unlock()
if !state.HasServer(newSvc.Hostname) {
state.Servers[newSvc.Hostname] = NewServer(newSvc.Hostname)
}
server := state.Se... | go | {
"resource": ""
} |
q11781 | Merge | train | func (state *ServicesState) Merge(otherState *ServicesState) {
for _, server := range otherState.Servers {
for _, service := range server.Services {
state.ServiceMsgs <- *service
}
}
} | go | {
"resource": ""
} |
q11782 | retransmit | train | func (state *ServicesState) retransmit(svc service.Service) {
// We don't retransmit our own events! We're already
// transmitting them.
if svc.Hostname == state.Hostname {
return
}
go func() {
encoded, err := svc.Encode()
if err != nil {
log.Errorf("ERROR encoding message to forward: (%s)", err.Error())... | go | {
"resource": ""
} |
q11783 | Print | train | func (state *ServicesState) Print(list *memberlist.Memberlist) {
log.Println(state.Format(list))
} | go | {
"resource": ""
} |
q11784 | TrackNewServices | train | func (state *ServicesState) TrackNewServices(fn func() []service.Service, looper director.Looper) {
looper.Loop(func() error {
for _, container := range fn() {
state.ServiceMsgs <- container
}
return nil
})
} | go | {
"resource": ""
} |
q11785 | TrackLocalListeners | train | func (state *ServicesState) TrackLocalListeners(fn func() []Listener, looper director.Looper) {
looper.Loop(func() error {
discovered := fn()
// Add new listeners
for _, listener := range discovered {
state.RLock()
_, ok := state.listeners[listener.Name()]
state.RUnlock()
if !ok {
log.Infof("Add... | go | {
"resource": ""
} |
q11786 | IsNewService | train | func (state *ServicesState) IsNewService(svc *service.Service) bool {
var found *service.Service
if state.HasServer(svc.Hostname) {
found = state.Servers[svc.Hostname].Services[svc.ID]
}
if found == nil || (!svc.IsTombstone() && svc.Status != found.Status) {
return true
}
return false
} | go | {
"resource": ""
} |
q11787 | BroadcastServices | train | func (state *ServicesState) BroadcastServices(fn func() []service.Service, looper director.Looper) {
lastTime := time.Unix(0, 0)
looper.Loop(func() error {
defer metrics.MeasureSince([]string{"services_state", "BroadcastServices"}, time.Now())
var services []service.Service
haveNewServices := false
services... | go | {
"resource": ""
} |
q11788 | SendServices | train | func (state *ServicesState) SendServices(services []service.Service, looper director.Looper) {
// Announce these every second for awhile
go func() {
defer metrics.MeasureSince([]string{"services_state", "SendServices"}, time.Now())
additionalTime := 0 * time.Second
looper.Loop(func() error {
var prepared []... | go | {
"resource": ""
} |
q11789 | ByService | train | func (state *ServicesState) ByService() map[string][]*service.Service {
serviceMap := make(map[string][]*service.Service)
state.EachServiceSorted(
func(hostname *string, serviceId *string, svc *service.Service) {
serviceMap[svc.Name] = append(serviceMap[svc.Name], svc)
},
)
return serviceMap
} | go | {
"resource": ""
} |
q11790 | Decode | train | func Decode(data []byte) (*ServicesState, error) {
newState := NewServicesState()
err := newState.UnmarshalJSON(data)
if err != nil {
log.Errorf("Error decoding state! (%s)", err.Error())
}
return newState, err
} | go | {
"resource": ""
} |
q11791 | New | train | func New(configFile string, pidFile string) *HAproxy {
reloadCmd := "haproxy -f " + configFile + " -p " + pidFile + " `[[ -f " + pidFile + " ]] && echo \"-sf $(cat " + pidFile + ")\"]]`"
verifyCmd := "haproxy -c -f " + configFile
proxy := HAproxy{
ReloadCmd: reloadCmd,
VerifyCmd: verifyCmd,
Template: "vie... | go | {
"resource": ""
} |
q11792 | sanitizeName | train | func sanitizeName(image string) string {
replace := regexp.MustCompile("[^a-z0-9-]")
return replace.ReplaceAllString(image, "-")
} | go | {
"resource": ""
} |
q11793 | findPortForService | train | func findPortForService(svcPort string, svc *service.Service) string {
matchPort, err := strconv.ParseInt(svcPort, 10, 64)
if err != nil {
log.Errorf("Invalid value from template ('%s') can't parse as int64: %s", svcPort, err.Error())
return "-1"
}
for _, port := range svc.Ports {
if port.ServicePort == matc... | go | {
"resource": ""
} |
q11794 | findIpForService | train | func (h *HAproxy) findIpForService(svcPort string, svc *service.Service) string {
// We can turn off using IP addresses in the config, which is sometimes
// necessary (e.g. w/Docker for Mac).
if h.UseHostnames {
return svc.Hostname
}
matchPort, err := strconv.ParseInt(svcPort, 10, 64)
if err != nil {
log.Err... | go | {
"resource": ""
} |
q11795 | swallowSignals | train | func (h *HAproxy) swallowSignals() {
// from HAproxy which propagate.
sigChan := make(chan os.Signal, 10)
// Used to stop the goroutine
h.sigStopChan = make(chan struct{})
go func() {
for {
select {
case <-sigChan:
// swallow signal
case <-h.sigStopChan:
break
}
}
}()
signal.Notify(sig... | go | {
"resource": ""
} |
q11796 | ResetSignals | train | func (h *HAproxy) ResetSignals() {
h.sigLock.Lock()
signal.Reset(syscall.SIGSTOP, syscall.SIGTSTP, syscall.SIGTTIN, syscall.SIGTTOU)
select {
case h.sigStopChan <- struct{}{}: // nothing
default:
}
h.sigLock.Unlock()
} | go | {
"resource": ""
} |
q11797 | run | train | func (h *HAproxy) run(command string) error {
cmd := exec.Command("/bin/bash", "-c", command)
stdout := &bytes.Buffer{}
stderr := &bytes.Buffer{}
cmd.Stdout = stdout
cmd.Stderr = stderr
// The end effect of this signal handling requirement is that we can only run _one_
// command at a time. This is totally fin... | go | {
"resource": ""
} |
q11798 | WriteAndReload | train | func (h *HAproxy) WriteAndReload(state *catalog.ServicesState) error {
if h.ConfigFile == "" {
return fmt.Errorf("Trying to write HAproxy config, but no filename specified!")
}
outfile, err := os.Create(h.ConfigFile)
if err != nil {
return fmt.Errorf("Unable to write to %s! (%s)", h.ConfigFile, err.Error())
}... | go | {
"resource": ""
} |
q11799 | UpdateHandler | train | func UpdateHandler(response http.ResponseWriter, req *http.Request, rcvr *Receiver) {
defer req.Body.Close()
response.Header().Set("Content-Type", "application/json")
data, err := ioutil.ReadAll(req.Body)
if err != nil {
message, _ := json.Marshal(ApiErrors{[]string{err.Error()}})
response.WriteHeader(http.Sta... | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.