id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1
value |
|---|---|---|
c27600 | {
return &attachClient{conn: conn, w: bufio.NewWriter(conn)}
} | |
c27601 | return nil, err
}
state := conn.ConnectionState()
hashFunc := c.Hash
if hashFunc == nil {
hashFunc = sha256.New
}
h := hashFunc()
h.Write(state.PeerCertificates[0].Raw)
if !bytes.Equal(h.Sum(nil), c.Pin) {
conn.Close()
return nil, ErrPinFailure
}
return conn, nil
} | |
c27602 |
}
return errors.New("pinned: underlying connection does not support CloseWrite")
} | |
c27603 | defer c.mu.RUnlock()
return c.leader, c.pinned
} | |
c27604 | defer c.mu.Unlock()
c.pinned = new
} | |
c27605 | c.servers[s]; !ok {
c.servers[s] = c.httpClient(s)
}
}
// Then remove any that are no longer current
for addr := range c.servers {
present := false
for _, s := range servers {
if _, ok := c.servers[s]; ok {
present = true
break
}
}
if !present {
delete(c.servers, addr)
}
}
} | |
c27606 | {
return nil, err
}
if err := syscall.Listen(fd, backlog); err != nil {
return nil, err
}
f := os.NewFile(uintptr(fd), proto+":"+addr)
l, err := net.FileListener(f)
if err != nil {
return nil, err
}
if err := f.Close(); err != nil {
l.Close()
return nil, err
}
return l, nil
} | |
c27607 |
c.URL = fmt.Sprintf("http://%s", addr)
return c
} | |
c27608 | Password: DefaultPassword,
OpTimeout: DefaultOpTimeout,
ReplTimeout: DefaultReplTimeout,
Logger: log15.New("app", "redis"),
}
p.stopping.Store(false)
return p
} | |
c27609 | have a config.
if p.running {
return ErrRunning
}
return p.start()
} | |
c27610 | p.mtx.Unlock()
if !p.running {
return ErrStopped
}
return p.stop()
} | |
c27611 |
if !p.stopping.Load().(bool) {
p.Logger.Error("unexpectedly exit", "err", err)
shutdown.ExitWithCode(1)
}
close(stopped)
} | |
c27612 | parent directory", "err", err)
return err
}
f, err := os.Create(p.ConfigPath())
if err != nil {
logger.Error("cannot create config file", "err", err)
return err
}
defer f.Close()
return configTemplate.Execute(f, struct {
ID string
Port string
DataDir string
Password string
}{p.ID, p.P... | |
c27613 | return &ProcessInfo{Running: p.running}, nil
} | |
c27614 | {
logger.Info("sending PING")
conn, err := redis.Dial("tcp", addr,
redis.DialPassword(p.Password),
redis.DialConnectTimeout(timeout),
redis.DialReadTimeout(timeout),
redis.DialWriteTimeout(timeout),
)
if err != nil {
logger.Error("conn error", "err", err)
return false
}
defer... | |
c27615 | timer.Stop()
for {
select {
case <-timer.C:
return ErrTimeout
case <-ticker.C:
}
if err := p.ping(addr, timeout); err != nil {
logger.Error("ping error", "err", err)
continue
}
return nil
}
} | |
c27616 | := func() error {
f, err := os.Create(filepath.Join(p.DataDir, "dump.rdb"))
if err != nil {
logger.Error("error creating dump file", "err", err)
return err
}
defer f.Close()
// Copy from reader to dump file.
n, err := io.Copy(f, r)
if err != nil {
logger.Error("error creating dump file", "err",... | |
c27617 | err != nil {
logger.Info("dial error", "err", err)
return nil, err
}
defer conn.Close()
// Execute INFO command.
reply, err := conn.Do("INFO")
if err != nil {
logger.Error("info error", "err", err)
return nil, err
}
buf, ok := reply.([]byte)
if !ok {
logger.Error("info reply type error", "type", fm... | |
c27618 | * time.Second
case "master_sync_in_progress":
info.MasterSyncInProgress = value == "1"
case "master_sync_left_bytes":
info.MasterSyncLeftBytes, _ = strconv.ParseInt(value, 10, 64)
case "master_sync_last_io_seconds_ago":
info.MasterSyncLastIO = time.Duration(atoi(value)) * time.Second
case "master_link... | |
c27619 | strconv.Atoi(s)
return i
} | |
c27620 |
return true
}
_, err := client.GetFormation(appID, prevReleaseID)
return err == controller.ErrNotFound
} | |
c27621 | range env {
for k := range envs {
if strings.HasPrefix(e, k+"=") {
continue outer
}
}
cmd.Env = append(cmd.Env, e)
}
for k, v := range envs {
cmd.Env = append(cmd.Env, k+"="+v)
}
} | |
c27622 | if _, err := syscall.Read(c.sock, msg); err != nil {
return err
}
if !bytes.Equal(msg, ControlMsgOK) {
return fmt.Errorf("unexpected resume message from child: %s", msg)
}
return nil
} | |
c27623 | {
return h, nil
}
}
return nil, fmt.Errorf("cluster: unknown host %q", id)
} | |
c27624 | inst.Meta["id"],
inst.Addr,
c.h,
HostTagsFromMeta(inst.Meta),
)
}
return hosts, nil
} | |
c27625 |
ports = append(ports, x.Ports...)
ports = append(ports, y.Ports...)
x.Ports = ports
if y.WorkingDir != "" {
x.WorkingDir = y.WorkingDir
}
if y.Uid != nil {
x.Uid = y.Uid
}
if y.Gid != nil {
x.Gid = y.Gid
}
x.HostNetwork = x.HostNetwork || y.HostNetwork
x.HostPIDNamespace = x.HostPIDNamespace || y.Host... | |
c27626 |
return err
}
defer f.Close()
src = f
}
return json.NewDecoder(src).Decode(v)
} | |
c27627 |
if m.db == nil {
m.dbMtx.RUnlock()
return ErrDBClosed
}
return nil
} | |
c27628 | {
return fmt.Errorf("could not persist provider volume info to boltdb: %s", err)
}
providerVolumesBucket := providerBucket.Bucket([]byte("volumes"))
if !volExists {
providerVolumesBucket.Delete(k)
} else {
b, err := vol.Provider().MarshalVolumeState(id)
if err != nil {
return fmt.Errorf("failed to seria... | |
c27629 | %s", old.String(), link.Attrs().Name)
}
}
if !existing {
if err = netlink.AddrAdd(link, &addr); err != nil {
return fmt.Errorf("failed to add IP address %s to %s: %s", ipn.String(), link.Attrs().Name, err)
}
}
return nil
} | |
c27630 | &Message{}
return msg, parse(buf, msg)
} | |
c27631 | }
msg := &message{Message: *m, prev: other}
if other.next != nil {
// insert between other and other.next
other.next.prev = msg
msg.next = other.next
} else {
// insert at tail
b.tail = msg
}
other.next = msg
break
}
}
if b.length < b.capacity {
// buffer not yet full
b.... | |
c27632 | defer b.mu.RUnlock()
return b.read()
} | |
c27633 | struct{}) []*rfc5424.Message {
b.mu.RLock()
defer b.mu.RUnlock()
b.subscribe(msgc, donec)
return b.read()
} | |
c27634 | <-chan struct{}) {
b.mu.RLock()
defer b.mu.RUnlock()
b.subscribe(msgc, donec)
} | |
c27635 | != nil {
buf = append(buf, &msg.Message)
msg = msg.next
}
return buf
} | |
c27636 | }
b.mu.Lock()
defer b.mu.Unlock()
delete(b.subs, msgc)
close(msgc)
}()
} | |
c27637 | {
return NewClientWithHTTP(uri, key, httphelper.RetryClient)
} | |
c27638 | config.Domain != "" {
d.Config = &tls.Config{ServerName: config.Domain}
}
httpClient := &http.Client{Transport: &http.Transport{DialTLS: d.Dial}}
c := newClient(key, uri, httpClient)
c.Host = config.Domain
c.HijackDial = d.Dial
return c, nil
} | |
c27639 | json.NewDecoder(conn),
enc: json.NewEncoder(conn),
c: conn,
pending: make(map[uint64]*json.RawMessage),
}
} | |
c27640 | interface{}) {
rpc.ServeCodecWithContext(NewServerCodec(conn), context)
} | |
c27641 |
if err := s.stateDB.Close(); err != nil {
return err
}
s.stateDB = nil
return nil
} | |
c27642 |
if s.stateDB == nil {
return ErrDBClosed
}
s.dbUsers++
return nil
} | |
c27643 | s.dbUsers == 0 {
s.dbCond.Broadcast()
}
} | |
c27644 | artifact := artifacts[i]
if artifact.Type != ct.ArtifactTypeFlynn {
continue
}
if e := artifact.Manifest().DefaultEntrypoint(); e != nil {
return e
}
}
return nil
} | |
c27645 | Type: host.MountspecTypeSquashfs,
ID: layer.ID,
URL: artifact.LayerURL(layer),
Size: layer.Length,
Hashes: layer.Hashes,
Meta: artifact.Meta,
})
}
}
} | |
c27646 | count <= -proc[typ] {
return true
}
}
return false
} | |
c27647 | if f.Processes[typ] != count {
f.Processes[typ] = count
changed = true
}
}
}
return changed
} | |
c27648 | Processes(f.Processes).Diff(running)
} | |
c27649 |
}
if err == tuf.ErrNoRootKeys {
if err := client.Init(tufconfig.RootKeys, len(tufconfig.RootKeys)); err != nil {
return err
}
return updateTUFClient(client)
}
return err
} | |
c27650 |
return j.Formation.Tags[j.Type]
} | |
c27651 | !ok || v != w {
return false
}
}
return true
} | |
c27652 | == typ {
jobs = append(jobs, job)
}
}
jobs.Sort()
return jobs
} | |
c27653 | m.jobsMtx.Lock()
defer m.jobsMtx.Unlock()
delete(m.jobWaits, config.JobID)
}()
}
// if there is a jobStart channel, a subscriber is waiting for the WaitGroup
// to be created, signal it.
if ch, ok := m.jobStarts[config.JobID]; ok {
close(ch)
delete(m.jobStarts, config.JobID)
}
go s.follow(r, buffer... | |
c27654 |
case <-stop:
return
}
m.jobsMtx.Lock()
wg, ok = m.jobWaits[jobID]
m.jobsMtx.Unlock()
if !ok {
// if there is no wg, it was created and deleted before we could
// read it, we're done
return
}
}
// wait for the job to finish
wg.Wait()
}()
return ch
} | |
c27655 | || !appIDPrefixPattern.MatchString(n) || !strings.HasPrefix(n, app) {
continue
}
appID := n[:36]
res[appID] = append(res[appID], filepath.Join(m.logDir, n))
}
return res, nil
} | |
c27656 | // we're the last user, clean it up
l.l.Close()
l.m.appLogsMtx.Lock()
delete(l.m.appLogs, l.appID)
l.m.appLogsMtx.Unlock()
}
} | |
c27657 | if child == nil {
// insert node if it doesn't exist
child = &node{children: make(map[string]*node, 0)}
cur.children[part] = child
}
cur = child
}
if i == -1 {
break
}
}
cur.backend = backend // finally set the backend for this node
} | |
c27658 | prev = cur // update last seen backend
}
}
if i == -1 {
break
}
}
if cur.backend != nil {
return cur.backend
}
return prev.backend
} | |
c27659 |
if path[start:start+end] == "/" {
return "", start + end + 1
}
return path[start : start+end], start + end + 1
} | |
c27660 | event.ObjectID {
return
}
select {
case e.queue <- event:
default:
// Run in a goroutine to avoid deadlock with Notify
go e.CloseWithError(ErrEventBufferOverflow)
}
} | |
c27661 | select {
case <-e.stop:
return
case event := <-e.queue:
e.Events <- event
}
}
} | |
c27662 |
e.stopOnce.Do(func() { close(e.stop) })
} | |
c27663 | error) {
e.errOnce.Do(func() { e.Err = err })
e.Close()
} | |
c27664 | make(chan struct{}),
appID: appID,
objectTypes: objectTypes,
objectID: objectID,
}
go s.loop()
if _, ok := e.subscribers[appID]; !ok {
e.subscribers[appID] = make(map[*EventSubscriber]struct{})
}
e.subscribers[appID][s] = struct{}{}
return s, nil
} | |
c27665 | delete(subs, s)
if len(subs) == 0 {
delete(e.subscribers, s.appID)
}
}
} | |
c27666 | if len(idApp) < 1 {
log.Error(fmt.Sprintf("invalid event notification: %q", n.Payload))
continue
}
id, err := strconv.ParseInt(idApp[0], 10, 64)
if err != nil {
log.Error(fmt.Sprintf("invalid event notification: %q", n.Payload), "err", err)
continue
}
event, err := e.eventRepo.... | |
c27667 |
// Ensure subscribers not filtering by app get the event
if subs, ok := e.subscribers[""]; ok {
for sub := range subs {
sub.Notify(event)
}
}
}
} | |
c27668 | e.closedMtx.RUnlock()
return e.closed
} | |
c27669 | e.subscribers
for _, subs := range subscribers {
for sub := range subs {
go sub.CloseWithError(err)
}
}
close(e.doneCh)
} | |
c27670 | return nil
}
// Reply type must be exported.
if !isExportedOrBuiltinType(replyType) {
log.Println("method", mname, "reply type not exported:", replyType)
return nil
}
// Method needs one out.
if mtype.NumOut() != 1 {
log.Println("method", mname, "has wrong number of outs:", mtype.NumOut())
return nil
... | |
c27671 | &gobServerCodec{conn, gob.NewDecoder(conn), gob.NewEncoder(buf), buf}
server.ServeCodecWithContext(srv, context)
} | |
c27672 | if !ok {
return
}
close(stop)
}()
continue
}
if !keepReading {
break
}
// send a response if we actually managed to read a header.
if req != nil {
server.sendResponse(sending, req, invalidRequest, codec, err.Error(), true)
server.freeRequest(req)
}
continue
... | |
c27673 | log.Fatal("rpc.Serve: accept:", err.Error()) // TODO(r): exit?
}
go server.ServeConn(conn)
}
} | |
c27674 | if err != nil {
log.Print("rpc hijacking ", req.RemoteAddr, ": ", err.Error())
return
}
io.WriteString(conn, "HTTP/1.0 "+connected+"\n\n")
server.ServeConn(conn)
} | |
c27675 | "--password="+p.Password,
"--socket=",
"--stream=xbstream",
".",
)
cmd.Dir = p.DataDir
cmd.Stderr = &r.stderr
stdout, err := cmd.StdoutPipe()
if err != nil {
return nil, err
}
if err := cmd.Start(); err != nil {
stdout.Close()
return nil, err
}
// Attach to reader wrapper.
r.cmd = cmd
r.stdout... | |
c27676 | err != nil {
return nil, err
}
if err := p.restoreApplyLog(); err != nil {
return nil, err
}
return backupInfo, nil
} | |
c27677 | "flynn",
Password: p.Password,
Timeout: p.OpTimeout,
}
} | |
c27678 | err
}
defer db.Close()
var gtid string
if err := db.QueryRow(`SELECT @@gtid_current_pos`).Scan(>id); err != nil {
return p.XLog().Zero(), err
}
return xlog.Position(gtid), nil
} | |
c27679 |
// Ignore errors, since the db could be already initialized
p.runCmd(exec.Command(
filepath.Join(p.BinDir, "mysql_install_db"),
"--defaults-extra-file="+p.ConfigPath(),
))
return nil
} | |
c27680 | !strings.HasSuffix(strings.TrimSpace(r.stderr.String()), "completed OK!") {
r.stderr.WriteTo(os.Stderr)
return errors.New("innobackupex did not complete ok")
}
return nil
} | |
c27681 | {
return r.stdout.Read(p)
} | |
c27682 | // lookup the service and pick a random address
service := strings.TrimSuffix(host, ".discoverd")
addrs, err := l.discoverdClient.Service(service).Addrs()
if err != nil {
return nil, err
} else if len(addrs) == 0 {
return nil, fmt.Errorf("lookup %s: no such host", host)
}
addr = addrs[random.Math.Int... | |
c27683 |
case routeTypeTCP:
tableName = tableNameTCP
default:
panic(fmt.Sprintf("unknown routeType: %q", routeType))
}
return &pgDataStore{
pgx: pgx,
routeType: routeType,
tableName: tableName,
}
} | |
c27684 | }
uriKey := prefix + "_IMAGE_URI"
if _, ok := env[uriKey]; ok {
delete(env, uriKey)
env[idKey] = newID
updated = true
}
}
return updated
} | |
c27685 |
parts, err := parse(pos)
if err != nil {
return "", err
}
return makePosition(parts[0], parts[1]+increment), nil
} | |
c27686 | res[0], err = parseHex(parts[0])
if err != nil {
return
}
res[1], err = parseHex(parts[1])
return
} | |
c27687 | {
return xlog.Position(fmt.Sprintf("%X/%08X", filepart, offset))
} | |
c27688 | return procTypeID[1], procTypeID[0]
}
return procTypeID[0], ""
} | |
c27689 | }
// Retrieve current formation.
logger.Info("retrieving formation", "app", app, "release_id", release.ID)
formation, err := client.GetFormation(app, release.ID)
if err == controller.ErrNotFound {
logger.Error("formation not found", "app", app, "release_id", release.ID)
return false, err
} else if err != nil... | |
c27690 |
worker.LaunchAsync(errorsChan)
return <-errorsChan
} | |
c27691 | broker consumption and handle retries when broker connection dies
go func() {
for {
retry, err := broker.StartConsuming(worker.ConsumerTag, worker.Concurrency, worker)
if retry {
if worker.errorHandler != nil {
worker.errorHandler(err)
} else {
log.WARNING.Printf("Broker failed with error: ... | |
c27692 | task by signature.RetryTimeout seconds
eta := time.Now().UTC().Add(time.Second * time.Duration(signature.RetryTimeout))
signature.ETA = &eta
log.WARNING.Printf("Task %s failed. Going to retry in %d seconds.", signature.UUID, signature.RetryTimeout)
// Send the task back to the queue
_, err := worker.server.Send... | |
c27693 | completed
groupCompleted, err := worker.server.GetBackend().GroupCompleted(
signature.GroupUUID,
signature.GroupTaskCount,
)
if err != nil {
return fmt.Errorf("Completed check for group %s returned error: %s", signature.GroupUUID, err)
}
// If the group has not yet completed, just return
if !groupComplete... | |
c27694 | range signature.OnError {
// Pass error as a first argument to error callbacks
args := append([]tasks.Arg{{
Type: "string",
Value: taskErr.Error(),
}}, errorTask.Args...)
errorTask.Args = args
worker.server.SendTask(errorTask)
}
return nil
} | |
c27695 | worker.server.GetBackend().(*amqp.Backend)
return ok
} | |
c27696 | error: %s", err)
}
// Bind the queue
if err = channel.QueueBind(
queue.Name, // name of the queue
queueBindingKey, // binding key
exchange, // source exchange
false, // noWait
queueBindingArgs, // arguments
); err != nil {
return conn, channel, queue, nil, nil, fmt.... | |
c27697 | messages removed
_, err := channel.QueueDelete(
queueName, // name
false, // ifUnused
false, // ifEmpty
false, // noWait
)
return err
} | |
c27698 |
return nil, fmt.Errorf("Queue inspect error: %s", err)
}
return &queueState, nil
} | |
c27699 | err != nil {
return nil, nil, fmt.Errorf("Dial error: %s", err)
}
// Open a channel
channel, err := conn.Channel()
if err != nil {
return nil, nil, fmt.Errorf("Open channel error: %s", err)
}
return conn, channel, nil
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.