id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1
value |
|---|---|---|
c27500 | c.c.Put(fmt.Sprintf("/host/jobs/%s", job.ID), job, nil)
} | |
c27501 | := c.c.Get(fmt.Sprintf("/host/jobs/%s", id), &res)
return &res, err
} | |
c27502 | {
return c.c.Delete(fmt.Sprintf("/host/jobs/%s", id))
} | |
c27503 | c.c.Put(fmt.Sprintf("/host/jobs/%s/signal/%d", id, sig), nil, nil)
} | |
c27504 | c.c.Put(fmt.Sprintf("/host/jobs/%s/discoverd-deregister", id), nil, nil)
} | |
c27505 | == "all" {
r = "/host/jobs"
}
return c.c.ResumingStream("GET", r, ch)
} | |
c27506 | c.c.Post(fmt.Sprintf("/storage/providers/%s/volumes", providerId), info, info)
} | |
c27507 | &volume, c.c.Get(fmt.Sprintf("/storage/volumes/%s", volumeID), &volume)
} | |
c27508 | return volumes, c.c.Get("/storage/volumes", &volumes)
} | |
c27509 | c.c.ResumingStream("GET", "/storage/volumes", ch)
} | |
c27510 | {
return c.c.Delete(fmt.Sprintf("/storage/volumes/%s", volumeID))
} | |
c27511 | c.c.Put(fmt.Sprintf("/storage/volumes/%s/snapshot", volumeID), nil, &res)
return &res, err
} | |
c27512 |
err := c.c.Post(fmt.Sprintf("/storage/volumes/%s/pull_snapshot", receiveVolID), pull, &res)
return &res, err
} | |
c27513 | configDir)
query.Set("version", version)
path := "/host/pull/images?" + query.Encode()
return c.c.StreamWithHeader("POST", path, header, tufDB, ch)
} | |
c27514 | version)
path := "/host/pull/binaries?" + query.Encode()
var paths map[string]string
return paths, c.c.Post(path, tufDB, &paths)
} | |
c27515 | if strings.HasPrefix(r.URL.Path, url) {
return true
}
}
return false
} | |
c27516 |
if err := h.Store.AddService(service, config); err == ErrNotLeader {
h.redirectToLeader(w, r)
return
} else if IsServiceExists(err) {
hh.ObjectExistsError(w, err.Error())
return
} else if err != nil {
hh.Error(w, err)
return
}
} | |
c27517 | if err := h.Store.RemoveService(params.ByName("service")); err == ErrNotLeader {
h.redirectToLeader(w, r)
return
} else if IsNotFound(err) {
hh.ObjectNotFoundError(w, err.Error())
return
} else if err != nil {
hh.Error(w, err)
return
}
} | |
c27518 |
// maintaining headers through a redirect.
//
// See https://github.com/flynn/flynn/issues/1880
h.serveStream(w, params, discoverd.EventKindAll)
} | |
c27519 | return
}
// Update the meta in the store.
if err := h.Store.SetServiceMeta(params.ByName("service"), meta); err == ErrNotLeader {
h.redirectToLeader(w, r)
return
} else if IsNotFound(err) {
hh.ObjectNotFoundError(w, err.Error())
return
} else if err != nil {
hh.Error(w, err)
return
}
// Write meta... | |
c27520 |
hh.ObjectNotFoundError(w, "service meta not found")
return
}
// Write meta to the response.
hh.JSON(w, 200, meta)
} | |
c27521 |
// Add instance to service in the store.
if err := h.Store.AddInstance(service, inst); err == ErrNotLeader {
h.redirectToLeader(w, r)
return
} else if IsNotFound(err) {
hh.ObjectNotFoundError(w, err.Error())
return
} else if err != nil {
hh.Error(w, err)
return
}
} | |
c27522 |
h.redirectToLeader(w, r)
return
} else if IsNotFound(err) {
hh.ObjectNotFoundError(w, err.Error())
return
} else if err != nil {
hh.Error(w, err)
return
}
} | |
c27523 | h.Store.Instances(params.ByName("service"))
if err != nil {
hh.Error(w, err)
return
} else if instances == nil {
hh.ObjectNotFoundError(w, fmt.Sprintf("service not found: %q", params.ByName("service")))
return
}
// Write instances to the response.
hh.JSON(w, 200, instances)
} | |
c27524 | != nil {
hh.Error(w, err)
return
}
// Manually set the leader on the service.
if err := h.Store.SetServiceLeader(service, inst.ID); err == ErrNotLeader {
h.redirectToLeader(w, r)
return
} else if err != nil {
hh.Error(w, err)
return
}
} | |
c27525 | params.ByName("service")
leader, err := h.Store.ServiceLeader(service)
if err != nil {
hh.Error(w, err)
return
} else if leader == nil {
hh.ObjectNotFoundError(w, "no leader found")
return
}
// Write leader to the response.
hh.JSON(w, 200, leader)
} | |
c27526 | params httprouter.Params) {
if err := h.Main.Promote(); err != nil {
hh.Error(w, err)
return
}
} | |
c27527 | params httprouter.Params) {
if err := h.Main.Demote(); err != nil {
hh.Error(w, err)
return
}
} | |
c27528 | // Create and serve an SSE stream.
s := sse.NewStream(w, ch, nil)
s.Serve()
s.Wait()
stream.Close()
// Check if there was an error while closing.
if err := stream.Err(); err != nil {
s.CloseWithError(err)
}
} | |
c27529 | hh.ServiceUnavailableError(w, ErrNoKnownLeader.Error())
return
}
hh.JSON(w, 200, dt.RaftLeader{Host: h.Store.Leader()})
} | |
c27530 | err != nil {
hh.Error(w, err)
}
hh.JSON(w, 200, peers)
} | |
c27531 | {
hh.Error(w, err)
return
}
var targetLogIndex dt.TargetLogIndex
targetLogIndex.LastIndex = h.Store.LastIndex()
hh.JSON(w, 200, targetLogIndex)
} | |
c27532 |
h.redirectToLeader(w, r)
return
} else if err != nil {
hh.Error(w, err)
return
}
} | |
c27533 | {
hh.ServiceUnavailableError(w, ErrNoKnownLeader.Error())
return
}
redirectToHost(w, r, leader)
} | |
c27534 | * time.Millisecond,
LeaderLeaseTimeout: 500 * time.Millisecond,
CommitTimeout: 50 * time.Millisecond,
InstanceTTL: DefaultInstanceTTL,
ExpiryCheckInterval: DefaultExpiryCheckInterval,
LogOutput: os.Stderr,
Now: time.Now,
}
} | |
c27535 | %s", err)
}
// Create the snapshot store.
ss, err := raft.NewFileSnapshotStore(s.path, 2, os.Stderr)
if err != nil {
return fmt.Errorf("snapshot store: %s", err)
}
// Create raft log.
//
// The mutex must be unlocked as initializing the raft store may
// call back into methods which acquire the lock (e.g.... | |
c27536 | nil; el = el.Next() {
go el.Value.(*subscription).Close()
}
}
if s.raft != nil {
s.raft.Shutdown().Error()
lastIdx = s.raft.LastIndex()
s.raft = nil
}
if s.transport != nil {
s.transport.Close()
s.transport = nil
}
if s.stableStore != nil {
s.stableStore.Close()
s.stableStore = nil
}
return... | |
c27537 | s.raft == nil {
return ""
}
return s.raft.Leader()
} | |
c27538 | If the incoming channel closed then close our leader channel.
if !ok {
close(s.leaderCh)
return
}
// Resend value to store's leader channel.
select {
case s.leaderCh <- isLeader:
default:
}
}
}
} | |
c27539 |
ch <- true
return ch
}
return s.leaderCh
} | |
c27540 | = ErrNotLeader
} else if err == raft.ErrKnownPeer {
return nil
}
return err
} | |
c27541 | = ErrNotLeader
} else if err == raft.ErrUnknownPeer {
return nil
}
return err
} | |
c27542 | s.raft.SetPeers(peers).Error()
} | |
c27543 | range s.data.Services {
a = append(a, name)
}
sort.Strings(a)
return a
} | |
c27544 | if err != nil {
return err
}
if _, err := s.raftApply(addServiceCommandType, cmd); err != nil {
return err
}
return err
} | |
c27545 | defer s.mu.RUnlock()
return s.data.Services[service]
} | |
c27546 | := s.raftApply(removeServiceCommandType, cmd); err != nil {
return err
}
return nil
} | |
c27547 |
defer s.mu.Unlock()
return s.instances(service), nil
} | |
c27548 | defer s.mu.Unlock()
return s.serviceMeta(service)
} | |
c27549 | Service: service,
ID: id,
})
if err != nil {
return err
}
if _, err := s.raftApply(setLeaderCommandType, cmd); err != nil {
return err
}
return nil
} | |
c27550 | := range s.data.Instances[service] {
if leader == nil || inst.Index < leader.Index {
leader = inst
}
}
// Retrieve the leader ID.
var leaderID string
if leader != nil {
leaderID = leader.ID
}
// Set leader.
s.data.Leaders[service] = leaderID
// Broadcast event.
if prevLeaderID != leaderID {
var ... | |
c27551 | select {
case <-s.closing:
return
case <-ticker.C:
}
// Check all instances for expiration.
if err := s.EnforceExpiry(); err != nil && err != raft.ErrNotLeader {
s.logger.Printf("enforce expiry: %s", err)
}
}
} | |
c27552 | }
logger.Info("marking instance for expiry",
"fn", "EnforceExpiry",
"service", service,
"instance.id", inst.ID,
"instance.addr", inst.Addr,
)
// Add to list of instances to expire.
// The current expiry time is added to prevent a race condition of
// instances updating thei... | |
c27553 | // Apply to raft and receive an ApplyFuture back.
f := s.raft.Apply(buf, 30*time.Second)
if err := f.Error(); err == raft.ErrNotLeader {
return 0, ErrNotLeader // hide underlying implementation error
} else if err != nil {
return f.Index(), err
} else if err, ok := f.Response().(error); ok {
return f.Index()... | |
c27554 | != nil {
return nil, err
}
return &raftSnapshot{data: buf}, nil
} | |
c27555 | json.NewDecoder(r).Decode(data); err != nil {
return err
}
s.data = data
return nil
} | |
c27556 | != nil {
ch <- &discoverd.Event{
Service: service,
Kind: discoverd.EventKindLeader,
Instance: leader,
}
}
// Send current service meta data.
if meta := s.serviceMeta(service); sendCurrent && kinds.Any(discoverd.EventKindServiceMeta) && meta != nil {
ch <- &discoverd.Event{
Service: servi... | |
c27557 | continue
}
// Send event to subscriber.
// If subscriber is blocked then close it.
select {
case sub.ch <- event:
default:
sub.err = ErrSendBlocked
go sub.Close()
}
}
} | |
c27558 | {
sink.Cancel()
return err
}
// Close and exit.
return sink.Close()
} | |
c27559 | 0, len(d.Instances[service]))
for _, i := range d.Instances[service] {
a = append(a, i)
}
sort.Sort(instanceSlice(a))
return a
} | |
c27560 | {
if (r < 'a' || r > 'z') && (r < '0' || r > '9') && r != '-' {
return ErrInvalidService
}
}
return nil
} | |
c27561 |
client := discoverd.NewClientWithURL("http://" + host)
return client.Service(service).Instances()
} | |
c27562 | &raftLayer{
ln: ln,
addr: addr,
}
} | |
c27563 |
c.client.request.ServiceMethod = "CloseStream"
c.client.request.Seq = c.seq
return c.client.codec.WriteRequest(&c.client.request, struct{}{})
} | |
c27564 | gob.NewDecoder(conn), gob.NewEncoder(encBuf), encBuf}
return NewClientWithCodec(client)
} | |
c27565 | DialHTTPPath(network, address, DefaultRPCPath, nil)
} | |
c27566 | err != nil {
return nil, err
}
client, err := NewHTTPClient(conn, path, nil)
if err != nil {
conn.Close()
return nil, &net.OpError{
Op: "dial-http",
Net: network + " " + address,
Addr: nil,
Err: err,
}
}
return client, nil
} | |
c27567 | return nil, err
}
return NewClient(conn), nil
} | |
c27568 | channel, maybe?
if typ.Kind() != reflect.Chan || typ.Elem().Kind() != reflect.Ptr {
log.Panic("rpc: replyStream is not a channel of pointers")
return nil
}
call := new(Call)
call.ServiceMethod = serviceMethod
call.Args = args
call.Reply = replyStream
call.Stream = true
call.sent = make(chan struct{})
cal... | |
c27569 |
u.User = url.User(dsn.User)
} else {
u.User = url.UserPassword(dsn.User, dsn.Password)
}
// Remove leading double-slash.
return strings.TrimPrefix(u.String(), "//")
} | |
c27570 | l := range leases {
select {
case work <- l:
case success := <-results:
if success {
close(work)
return nil
}
}
}
close(work)
for success := range results {
if success {
return nil
}
}
return errors.New("failed to successfully ping a neighbor")
} | |
c27571 | }
data, ok := v.(bool)
if !ok || !data {
continue
}
proc["volumes"] = []struct {
Path string `json:"path"`
}{
{Path: "/data"},
}
delete(proc, "data")
release.Processes[typ] = proc
}
// save the processes back to the db
if err := tx.Exec("UPDATE releases SET processes = $1 W... | |
c27572 | {
r.mtx.Lock()
r.final = true
r.Backend = backend
r.mtx.Unlock()
} | |
c27573 | = info.Reused
trace.WasIdleConn = info.WasIdle
},
WroteHeaders: func() {
trace.mtx.Lock()
defer trace.mtx.Unlock()
if trace.final {
return
}
trace.HeadersWritten = time.Now()
},
WroteRequest: func(info httptrace.WroteRequestInfo) {
trace.mtx.Lock()
defer trace.mtx.Unlock()
if tra... | |
c27574 | execAttempts.Run(func() error {
return c.db.Exec(query, args...)
})
} | |
c27575 | TypeIntegers:
v := new(Integers)
return *v, v.UnmarshalBinary(b)
case TypeStrings:
v := new(Strings)
return *v, v.UnmarshalBinary(b)
case TypeRegexp:
v := new(Regexp)
return v, v.UnmarshalBinary(b)
case TypeCIDRs:
v := new(CIDRs)
return *v, v.UnmarshalBinary(b)
default:
return nil, fmt.Errorf("co... | |
c27576 | bytes.Join([][]byte{[]byte(strconv.Itoa(len(msg))), msg}, []byte{' '})
} | |
c27577 | int, token []byte, err error) {
return split(false, data, atEOF)
} | |
c27578 | error) {
return split(true, data, atEOF)
} | |
c27579 | := io.Copy(pw, conn)
if err == nil {
err = io.EOF
}
pw.CloseWithError(err)
close(c.cnc)
}()
return c
} | |
c27580 | return err
}
return json.Unmarshal(data, v)
} | |
c27581 | if known, ok := knownSubnets[subnet]; ok && reflect.DeepEqual(known, data) {
continue
}
subnets[subnet] = []byte(*data)
}
knownSubnets = net.Subnets
if event.ServiceMeta.Index >= since {
return &subnet.Response{Subnets: subnets, Index: event.ServiceMeta.Index}, nil
}
case <-stop:
retu... | |
c27582 |
if !verbose {
stdoutHandler = log15.LvlFilterHandler(log15.LvlInfo, stdoutHandler)
}
log := log15.New()
log.SetHandler(log15.MultiHandler(
log15.Must.FileHandler(file, log15.LogfmtFormat()),
stdoutHandler,
))
return log
} | |
c27583 | {
select {
case out := <-output:
// if we have printed the bar, replace it with
// spaces then write the output on the same line
if len(barText) > 0 {
spaces := make([]byte, len(barText))
for i := 0; i < len(barText); i++ {
spaces[i] = ' '
}
fmt.Fprint(stderr, "\r", string(s... | |
c27584 | }
if target.Custom == nil || len(*target.Custom) == 0 {
return "", errors.New("missing custom metadata in tuf target")
}
var data struct {
Version string
}
json.Unmarshal(*target.Custom, &data)
if data.Version == "" {
return "", errors.New("missing version in tuf target")
}
return data.Version, nil
} | |
c27585 | := err.(JSONError)
return ok && e.Retry
} | |
c27586 | return
}
time.AfterFunc(delay, p.triggerEval)
} | |
c27587 | log.Warn("would takeover but no peers present")
return
}
newAsync := make([]*discoverd.Instance, 0, len(p.Info().Peers))
for _, a := range p.Info().Peers {
if a.Meta[p.idKey] != p.id && a.Meta[p.idKey] != newSync.Meta[p.idKey] {
newAsync = append(newAsync, a)
}
}
log.Debug("transitioning to normal mode... | |
c27588 | {
if *p.online {
log.Debug("skipping start, already online")
} else {
log.Debug("starting database")
if err := p.db.Start(); err != nil {
return err
}
}
} else {
if *p.online {
log.Debug("stopping database")
if err := p.db.Stop(); err != nil {
return err
}
} else {
log.Debug(... | |
c27589 | p.id == a.Meta[p.idKey] {
return i
}
}
return -1
} | |
c27590 | p.Info().State.Sync
}
return p.Info().State.Async[whichAsync-1]
} | |
c27591 | whichAsync == len(async)-1 {
return nil
}
return async[whichAsync+1]
} | |
c27592 | == p.id {
panic("peerIsPresent with self")
}
for _, peer := range p.Info().Peers {
if peer.Meta[p.idKey] == other.Meta[p.idKey] {
return true
}
}
return false
} | |
c27593 | stickyCookieKey: stickyKey,
useStickySessions: sticky,
},
FlushInterval: 10 * time.Millisecond,
RequestTracker: rt,
Logger: l,
}
} | |
c27594 | }
}()
l := p.Logger.New("client_addr", dconn.RemoteAddr(), "host_addr", dconn.LocalAddr(), "proxy", "tcp")
uconn, err := transport.Connect(ctx, l)
if err != nil {
return
}
defer uconn.Close()
joinConns(uconn, dconn)
} | |
c27595 | if event.Kind == discoverd.EventKindServiceMeta {
d.meta = event.ServiceMeta
}
default:
}
return nil
} | |
c27596 |
return err
}
deploymentMeta.States[addr] = DeploymentStateDone
return d.set(d.meta, deploymentMeta)
})
} | |
c27597 | actual++
}
}
if actual == d.jobCount {
return nil
}
} else {
log.Warn("ignoring service meta even with wrong ID", "expected", id, "got", deploymentMeta.ID)
}
}
case <-timeoutCh:
return fmt.Errorf("timed out waiting for discoverd deployment (expected=%d actual=%d)", d.jo... | |
c27598 | d.update(); err != nil {
return err
}
return d.set(d.meta, NewDeploymentMeta(id))
})
} | |
c27599 | rwc.Close()
return fmt.Errorf("cluster: unknown attach state: %d", attachState)
}
}
if attachState[0] == host.AttachWaiting {
if !wait {
rwc.Close()
return nil, ErrWouldWait
}
wait := func() error {
if _, err := rwc.Read(attachState); err != nil {
rwc.Close()
return err
}
return ha... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.