_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q32400 | nodeInfo | train | func (ns *nodeSet) nodeInfo(nodeID string) (NodeInfo, error) {
node, ok := ns.nodes[nodeID]
if ok {
return node, nil
}
return NodeInfo{}, errNodeNotFound
} | go | {
"resource": ""
} |
q32401 | addOrUpdateNode | train | func (ns *nodeSet) addOrUpdateNode(n NodeInfo) {
ns.nodes[n.ID] = n
} | go | {
"resource": ""
} |
q32402 | updateNode | train | func (ns *nodeSet) updateNode(n NodeInfo) {
_, ok := ns.nodes[n.ID]
if ok {
ns.nodes[n.ID] = n
}
} | go | {
"resource": ""
} |
q32403 | setTasksDesiredState | train | func (r *Orchestrator) setTasksDesiredState(ctx context.Context, batch *store.Batch, slots []orchestrator.Slot, newDesiredState api.TaskState) {
for _, slot := range slots {
for _, t := range slot {
err := batch.Update(func(tx store.Tx) error {
// time travel is not allowed. if the current desired state is
... | go | {
"resource": ""
} |
q32404 | DefaultConfig | train | func DefaultConfig() *Config {
return &Config{
HeartbeatPeriod: DefaultHeartBeatPeriod,
HeartbeatEpsilon: defaultHeartBeatEpsilon,
RateLimitPeriod: defaultRateLimitPeriod,
GracePeriodMultiplier: defaultGracePeriodMultiplier,
}
} | go | {
"resource": ""
} |
q32405 | Init | train | func (d *Dispatcher) Init(cluster Cluster, c *Config, dp *drivers.DriverProvider, securityConfig *ca.SecurityConfig) {
d.cluster = cluster
d.config = c
d.securityConfig = securityConfig
d.dp = dp
d.store = cluster.MemoryStore()
d.nodes = newNodeStore(c.HeartbeatPeriod, c.HeartbeatEpsilon, c.GracePeriodMultiplier,... | go | {
"resource": ""
} |
q32406 | Stop | train | func (d *Dispatcher) Stop() error {
d.mu.Lock()
if !d.isRunning() {
d.mu.Unlock()
return errors.New("dispatcher is already stopped")
}
log := log.G(d.ctx).WithField("method", "(*Dispatcher).Stop")
log.Info("dispatcher stopping")
d.cancel()
d.mu.Unlock()
d.processUpdatesLock.Lock()
// when we called d.can... | go | {
"resource": ""
} |
q32407 | markNodeReady | train | func (d *Dispatcher) markNodeReady(ctx context.Context, nodeID string, description *api.NodeDescription, addr string) error {
d.nodeUpdatesLock.Lock()
d.nodeUpdates[nodeID] = nodeUpdate{
status: &api.NodeStatus{
State: api.NodeStatus_READY,
Addr: addr,
},
description: description,
}
numUpdates := len(d... | go | {
"resource": ""
} |
q32408 | nodeIPFromContext | train | func nodeIPFromContext(ctx context.Context) (string, error) {
nodeInfo, err := ca.RemoteNode(ctx)
if err != nil {
return "", err
}
addr, _, err := net.SplitHostPort(nodeInfo.RemoteAddr)
if err != nil {
return "", errors.Wrap(err, "unable to get ip from addr:port")
}
return addr, nil
} | go | {
"resource": ""
} |
q32409 | register | train | func (d *Dispatcher) register(ctx context.Context, nodeID string, description *api.NodeDescription) (string, error) {
logLocal := log.G(ctx).WithField("method", "(*Dispatcher).register")
// prevent register until we're ready to accept it
dctx, err := d.isRunningLocked()
if err != nil {
return "", err
}
if err ... | go | {
"resource": ""
} |
q32410 | UpdateTaskStatus | train | func (d *Dispatcher) UpdateTaskStatus(ctx context.Context, r *api.UpdateTaskStatusRequest) (*api.UpdateTaskStatusResponse, error) {
d.rpcRW.RLock()
defer d.rpcRW.RUnlock()
dctx, err := d.isRunningLocked()
if err != nil {
return nil, err
}
nodeInfo, err := ca.RemoteNode(ctx)
if err != nil {
return nil, err
... | go | {
"resource": ""
} |
q32411 | markNodeNotReady | train | func (d *Dispatcher) markNodeNotReady(id string, state api.NodeStatus_State, message string) error {
logLocal := log.G(d.ctx).WithField("method", "(*Dispatcher).markNodeNotReady")
dctx, err := d.isRunningLocked()
if err != nil {
return err
}
// Node is down. Add it to down nodes so that we can keep
// track o... | go | {
"resource": ""
} |
q32412 | Heartbeat | train | func (d *Dispatcher) Heartbeat(ctx context.Context, r *api.HeartbeatRequest) (*api.HeartbeatResponse, error) {
d.rpcRW.RLock()
defer d.rpcRW.RUnlock()
// TODO(anshul) Explore if its possible to check context here without locking.
if _, err := d.isRunningLocked(); err != nil {
return nil, status.Errorf(codes.Abor... | go | {
"resource": ""
} |
q32413 | NewNode | train | func NewNode(opts NodeOptions) *Node {
cfg := opts.Config
if cfg == nil {
cfg = DefaultNodeConfig()
}
if opts.TickInterval == 0 {
opts.TickInterval = time.Second
}
if opts.SendTimeout == 0 {
opts.SendTimeout = 2 * time.Second
}
raftStore := raft.NewMemoryStorage()
n := &Node{
cluster: membership.Ne... | go | {
"resource": ""
} |
q32414 | IsIDRemoved | train | func (n *Node) IsIDRemoved(id uint64) bool {
return n.cluster.IsIDRemoved(id)
} | go | {
"resource": ""
} |
q32415 | NodeRemoved | train | func (n *Node) NodeRemoved() {
n.removeRaftOnce.Do(func() {
atomic.StoreUint32(&n.isMember, 0)
close(n.RemovedFromRaft)
})
} | go | {
"resource": ""
} |
q32416 | ReportSnapshot | train | func (n *Node) ReportSnapshot(id uint64, status raft.SnapshotStatus) {
n.raftNode.ReportSnapshot(id, status)
} | go | {
"resource": ""
} |
q32417 | SetAddr | train | func (n *Node) SetAddr(ctx context.Context, addr string) error {
n.addrLock.Lock()
defer n.addrLock.Unlock()
n.opts.Addr = addr
if !n.IsMember() {
return nil
}
newRaftMember := &api.RaftMember{
RaftID: n.Config.ID,
NodeID: n.opts.ID,
Addr: addr,
}
if err := n.cluster.UpdateMember(n.Config.ID, newRa... | go | {
"resource": ""
} |
q32418 | WithContext | train | func (n *Node) WithContext(ctx context.Context) (context.Context, context.CancelFunc) {
ctx, cancel := context.WithCancel(ctx)
go func() {
select {
case <-ctx.Done():
case <-n.stopped:
cancel()
}
}()
return ctx, cancel
} | go | {
"resource": ""
} |
q32419 | JoinAndStart | train | func (n *Node) JoinAndStart(ctx context.Context) (err error) {
ctx, cancel := n.WithContext(ctx)
defer func() {
cancel()
if err != nil {
n.stopMu.Lock()
// to shutdown transport
n.cancelFunc()
n.stopMu.Unlock()
n.done()
} else {
atomic.StoreUint32(&n.isMember, 1)
}
}()
loadAndStartErr := ... | go | {
"resource": ""
} |
q32420 | DefaultNodeConfig | train | func DefaultNodeConfig() *raft.Config {
return &raft.Config{
HeartbeatTick: 1,
// Recommended value in etcd/raft is 10 x (HeartbeatTick).
// Lower values were seen to have caused instability because of
// frequent leader elections when running on flakey networks.
ElectionTick: 10,
MaxSizePerMsg: math.... | go | {
"resource": ""
} |
q32421 | DefaultRaftConfig | train | func DefaultRaftConfig() api.RaftConfig {
return api.RaftConfig{
KeepOldSnapshots: 0,
SnapshotInterval: 10000,
LogEntriesForSlowFollowers: 500,
// Recommended value in etcd/raft is 10 x (HeartbeatTick).
// Lower values were seen to have caused instability because of
// frequent leader e... | go | {
"resource": ""
} |
q32422 | isLeader | train | func (n *Node) isLeader() bool {
if !n.IsMember() {
return false
}
if n.Status().Lead == n.Config.ID {
return true
}
return false
} | go | {
"resource": ""
} |
q32423 | IsLeader | train | func (n *Node) IsLeader() bool {
n.stopMu.RLock()
defer n.stopMu.RUnlock()
return n.isLeader()
} | go | {
"resource": ""
} |
q32424 | Leader | train | func (n *Node) Leader() (uint64, error) {
n.stopMu.RLock()
defer n.stopMu.RUnlock()
if !n.IsMember() {
return raft.None, ErrNoRaftMember
}
leader := n.leader()
if leader == raft.None {
return raft.None, ErrNoClusterLeader
}
return leader, nil
} | go | {
"resource": ""
} |
q32425 | checkHealth | train | func (n *Node) checkHealth(ctx context.Context, addr string, timeout time.Duration) error {
conn, err := dial(addr, "tcp", n.opts.TLSCredentials, timeout)
if err != nil {
return err
}
defer conn.Close()
if timeout != 0 {
tctx, cancel := context.WithTimeout(ctx, timeout)
defer cancel()
ctx = tctx
}
hea... | go | {
"resource": ""
} |
q32426 | addMember | train | func (n *Node) addMember(ctx context.Context, addr string, raftID uint64, nodeID string) error {
node := api.RaftMember{
RaftID: raftID,
NodeID: nodeID,
Addr: addr,
}
meta, err := node.Marshal()
if err != nil {
return err
}
cc := raftpb.ConfChange{
Type: raftpb.ConfChangeAddNode,
NodeID: raftI... | go | {
"resource": ""
} |
q32427 | updateNodeBlocking | train | func (n *Node) updateNodeBlocking(ctx context.Context, id uint64, addr string) error {
m := n.cluster.GetMember(id)
if m == nil {
return errors.Errorf("member %x is not found for update", id)
}
node := api.RaftMember{
RaftID: m.RaftID,
NodeID: m.NodeID,
Addr: addr,
}
meta, err := node.Marshal()
if err... | go | {
"resource": ""
} |
q32428 | UpdateNode | train | func (n *Node) UpdateNode(id uint64, addr string) {
ctx, cancel := n.WithContext(context.Background())
defer cancel()
// spawn updating info in raft in background to unblock transport
go func() {
if err := n.updateNodeBlocking(ctx, id, addr); err != nil {
log.G(ctx).WithFields(logrus.Fields{"raft_id": n.Config... | go | {
"resource": ""
} |
q32429 | Leave | train | func (n *Node) Leave(ctx context.Context, req *api.LeaveRequest) (*api.LeaveResponse, error) {
if req.Node == nil {
return nil, status.Errorf(codes.InvalidArgument, "no node information provided")
}
nodeInfo, err := ca.RemoteNode(ctx)
if err != nil {
return nil, err
}
ctx, cancel := n.WithContext(ctx)
defe... | go | {
"resource": ""
} |
q32430 | CanRemoveMember | train | func (n *Node) CanRemoveMember(id uint64) bool {
members := n.cluster.Members()
nreachable := 0 // reachable managers after removal
for _, m := range members {
if m.RaftID == id {
continue
}
// Local node from where the remove is issued
if m.RaftID == n.Config.ID {
nreachable++
continue
}
if ... | go | {
"resource": ""
} |
q32431 | TransferLeadership | train | func (n *Node) TransferLeadership(ctx context.Context) error {
ctx, cancelTransfer := context.WithTimeout(ctx, n.reqTimeout())
defer cancelTransfer()
n.stopMu.RLock()
defer n.stopMu.RUnlock()
if !n.IsMember() {
return ErrNoRaftMember
}
if !n.isLeader() {
return ErrLostLeadership
}
transferee, err := n.... | go | {
"resource": ""
} |
q32432 | RemoveMember | train | func (n *Node) RemoveMember(ctx context.Context, id uint64) error {
ctx, cancel := n.WithContext(ctx)
defer cancel()
return n.removeMember(ctx, id)
} | go | {
"resource": ""
} |
q32433 | processRaftMessageLogger | train | func (n *Node) processRaftMessageLogger(ctx context.Context, msg *api.ProcessRaftMessageRequest) *logrus.Entry {
fields := logrus.Fields{
"method": "(*Node).ProcessRaftMessage",
}
if n.IsMember() {
fields["raft_id"] = fmt.Sprintf("%x", n.Config.ID)
}
if msg != nil && msg.Message != nil {
fields["from"] = f... | go | {
"resource": ""
} |
q32434 | StreamRaftMessage | train | func (n *Node) StreamRaftMessage(stream api.Raft_StreamRaftMessageServer) error {
// recvdMsg is the current messasge received from the stream.
// assembledMessage is where the data from recvdMsg is appended to.
var recvdMsg, assembledMessage *api.StreamRaftMessageRequest
var err error
// First message index.
va... | go | {
"resource": ""
} |
q32435 | ProcessRaftMessage | train | func (n *Node) ProcessRaftMessage(ctx context.Context, msg *api.ProcessRaftMessageRequest) (*api.ProcessRaftMessageResponse, error) {
if msg == nil || msg.Message == nil {
n.processRaftMessageLogger(ctx, msg).Debug("received empty message")
return &api.ProcessRaftMessageResponse{}, nil
}
// Don't process the me... | go | {
"resource": ""
} |
q32436 | ResolveAddress | train | func (n *Node) ResolveAddress(ctx context.Context, msg *api.ResolveAddressRequest) (*api.ResolveAddressResponse, error) {
if !n.IsMember() {
return nil, ErrNoRaftMember
}
nodeInfo, err := ca.RemoteNode(ctx)
if err != nil {
return nil, err
}
fields := logrus.Fields{
"node.id": nodeInfo.NodeID,
"method": ... | go | {
"resource": ""
} |
q32437 | LeaderConn | train | func (n *Node) LeaderConn(ctx context.Context) (*grpc.ClientConn, error) {
cc, err := n.getLeaderConn()
if err == nil {
return cc, nil
}
if err == raftselector.ErrIsLeader {
return nil, err
}
if atomic.LoadUint32(&n.ticksWithNoLeader) > lostQuorumTimeout {
return nil, errLostQuorum
}
ticker := time.NewTi... | go | {
"resource": ""
} |
q32438 | registerNode | train | func (n *Node) registerNode(node *api.RaftMember) error {
if n.cluster.IsIDRemoved(node.RaftID) {
return nil
}
member := &membership.Member{}
existingMember := n.cluster.GetMember(node.RaftID)
if existingMember != nil {
// Member already exists
// If the address is different from what we thought it was,
... | go | {
"resource": ""
} |
q32439 | GetVersion | train | func (n *Node) GetVersion() *api.Version {
n.stopMu.RLock()
defer n.stopMu.RUnlock()
if !n.IsMember() {
return nil
}
status := n.Status()
return &api.Version{Index: status.Commit}
} | go | {
"resource": ""
} |
q32440 | ChangesBetween | train | func (n *Node) ChangesBetween(from, to api.Version) ([]state.Change, error) {
n.stopMu.RLock()
defer n.stopMu.RUnlock()
if from.Index > to.Index {
return nil, errors.New("versions are out of order")
}
if !n.IsMember() {
return nil, ErrNoRaftMember
}
// never returns error
last, _ := n.raftStore.LastIndex... | go | {
"resource": ""
} |
q32441 | SubscribePeers | train | func (n *Node) SubscribePeers() (q chan events.Event, cancel func()) {
return n.cluster.PeersBroadcast.Watch()
} | go | {
"resource": ""
} |
q32442 | GetMemberlist | train | func (n *Node) GetMemberlist() map[uint64]*api.RaftMember {
memberlist := make(map[uint64]*api.RaftMember)
members := n.cluster.Members()
leaderID, err := n.Leader()
if err != nil {
leaderID = raft.None
}
for id, member := range members {
reachability := api.RaftMemberStatus_REACHABLE
leader := false
if... | go | {
"resource": ""
} |
q32443 | GetMemberByNodeID | train | func (n *Node) GetMemberByNodeID(nodeID string) *membership.Member {
members := n.cluster.Members()
for _, member := range members {
if member.NodeID == nodeID {
return member
}
}
return nil
} | go | {
"resource": ""
} |
q32444 | GetNodeIDByRaftID | train | func (n *Node) GetNodeIDByRaftID(raftID uint64) (string, error) {
if member, ok := n.cluster.Members()[raftID]; ok {
return member.NodeID, nil
}
// this is the only possible error value that should be returned; the
// manager code depends on this. if you need to add more errors later, make
// sure that you updat... | go | {
"resource": ""
} |
q32445 | saveToStorage | train | func (n *Node) saveToStorage(
ctx context.Context,
raftConfig *api.RaftConfig,
hardState raftpb.HardState,
entries []raftpb.Entry,
snapshot raftpb.Snapshot,
) (err error) {
if !raft.IsEmptySnap(snapshot) {
if err := n.raftLogger.SaveSnapshot(snapshot); err != nil {
return errors.Wrap(err, "failed to save sn... | go | {
"resource": ""
} |
q32446 | configure | train | func (n *Node) configure(ctx context.Context, cc raftpb.ConfChange) error {
cc.ID = n.reqIDGen.Next()
ctx, cancel := context.WithCancel(ctx)
ch := n.wait.register(cc.ID, nil, cancel)
if err := n.raftNode.ProposeConfChange(ctx, cc); err != nil {
n.wait.cancel(cc.ID)
return err
}
select {
case x := <-ch:
... | go | {
"resource": ""
} |
q32447 | applyAddNode | train | func (n *Node) applyAddNode(cc raftpb.ConfChange) error {
member := &api.RaftMember{}
err := proto.Unmarshal(cc.Context, member)
if err != nil {
return err
}
// ID must be non zero
if member.RaftID == 0 {
return nil
}
return n.registerNode(member)
} | go | {
"resource": ""
} |
q32448 | applyUpdateNode | train | func (n *Node) applyUpdateNode(ctx context.Context, cc raftpb.ConfChange) error {
newMember := &api.RaftMember{}
err := proto.Unmarshal(cc.Context, newMember)
if err != nil {
return err
}
if newMember.RaftID == n.Config.ID {
return nil
}
if err := n.transport.UpdatePeer(newMember.RaftID, newMember.Addr); er... | go | {
"resource": ""
} |
q32449 | applyRemoveNode | train | func (n *Node) applyRemoveNode(ctx context.Context, cc raftpb.ConfChange) (err error) {
// If the node from where the remove is issued is
// a follower and the leader steps down, Campaign
// to be the leader.
if cc.NodeID == n.leader() && !n.isLeader() {
if err = n.raftNode.Campaign(ctx); err != nil {
return ... | go | {
"resource": ""
} |
q32450 | SubscribeLeadership | train | func (n *Node) SubscribeLeadership() (q chan events.Event, cancel func()) {
return n.leadershipBroadcast.Watch()
} | go | {
"resource": ""
} |
q32451 | Parse | train | func Parse(env []string) ([]Constraint, error) {
exprs := []Constraint{}
for _, e := range env {
found := false
// each expr is in the form of "key op value"
for i, op := range operators {
if !strings.Contains(e, op) {
continue
}
// split with the op
parts := strings.SplitN(e, op, 2)
if len(... | go | {
"resource": ""
} |
q32452 | Match | train | func (c *Constraint) Match(whats ...string) bool {
var match bool
// full string match
for _, what := range whats {
// case insensitive compare
if strings.EqualFold(c.exp, what) {
match = true
break
}
}
switch c.operator {
case eq:
return match
case noteq:
return !match
}
return false
} | go | {
"resource": ""
} |
q32453 | InitDB | train | func InitDB(db *bolt.DB) error {
return db.Update(func(tx *bolt.Tx) error {
_, err := createBucketIfNotExists(tx, bucketKeyStorageVersion, bucketKeyTasks)
return err
})
} | go | {
"resource": ""
} |
q32454 | GetTask | train | func GetTask(tx *bolt.Tx, id string) (*api.Task, error) {
var t api.Task
if err := withTaskBucket(tx, id, func(bkt *bolt.Bucket) error {
p := bkt.Get(bucketKeyData)
if p == nil {
return errTaskUnknown
}
return proto.Unmarshal(p, &t)
}); err != nil {
return nil, err
}
return &t, nil
} | go | {
"resource": ""
} |
q32455 | WalkTasks | train | func WalkTasks(tx *bolt.Tx, fn func(task *api.Task) error) error {
bkt := getTasksBucket(tx)
if bkt == nil {
return nil
}
return bkt.ForEach(func(k, v []byte) error {
tbkt := bkt.Bucket(k)
p := tbkt.Get(bucketKeyData)
var t api.Task
if err := proto.Unmarshal(p, &t); err != nil {
return err
}
ret... | go | {
"resource": ""
} |
q32456 | TaskAssigned | train | func TaskAssigned(tx *bolt.Tx, id string) bool {
bkt := getTaskBucket(tx, id)
if bkt == nil {
return false
}
return len(bkt.Get(bucketKeyAssigned)) > 0
} | go | {
"resource": ""
} |
q32457 | GetTaskStatus | train | func GetTaskStatus(tx *bolt.Tx, id string) (*api.TaskStatus, error) {
var ts api.TaskStatus
if err := withTaskBucket(tx, id, func(bkt *bolt.Bucket) error {
p := bkt.Get(bucketKeyStatus)
if p == nil {
return errTaskUnknown
}
return proto.Unmarshal(p, &ts)
}); err != nil {
return nil, err
}
return &ts... | go | {
"resource": ""
} |
q32458 | WalkTaskStatus | train | func WalkTaskStatus(tx *bolt.Tx, fn func(id string, status *api.TaskStatus) error) error {
bkt := getTasksBucket(tx)
if bkt == nil {
return nil
}
return bkt.ForEach(func(k, v []byte) error {
tbkt := bkt.Bucket(k)
p := tbkt.Get(bucketKeyStatus)
var ts api.TaskStatus
if err := proto.Unmarshal(p, &ts); err... | go | {
"resource": ""
} |
q32459 | PutTask | train | func PutTask(tx *bolt.Tx, task *api.Task) error {
return withCreateTaskBucketIfNotExists(tx, task.ID, func(bkt *bolt.Bucket) error {
taskCopy := *task
taskCopy.Status = api.TaskStatus{} // blank out the status.
p, err := proto.Marshal(&taskCopy)
if err != nil {
return err
}
return bkt.Put(bucketKeyData... | go | {
"resource": ""
} |
q32460 | PutTaskStatus | train | func PutTaskStatus(tx *bolt.Tx, id string, status *api.TaskStatus) error {
return withCreateTaskBucketIfNotExists(tx, id, func(bkt *bolt.Bucket) error {
p, err := proto.Marshal(status)
if err != nil {
return err
}
return bkt.Put(bucketKeyStatus, p)
})
} | go | {
"resource": ""
} |
q32461 | DeleteTask | train | func DeleteTask(tx *bolt.Tx, id string) error {
bkt := getTasksBucket(tx)
if bkt == nil {
return nil
}
return bkt.DeleteBucket([]byte(id))
} | go | {
"resource": ""
} |
q32462 | SetTaskAssignment | train | func SetTaskAssignment(tx *bolt.Tx, id string, assigned bool) error {
return withTaskBucket(tx, id, func(bkt *bolt.Bucket) error {
if assigned {
return bkt.Put(bucketKeyAssigned, []byte{0xFF})
}
return bkt.Delete(bucketKeyAssigned)
})
} | go | {
"resource": ""
} |
q32463 | InterpolateService | train | func InterpolateService(origSpec *api.ServiceSpec) *api.ServiceSpec {
spec := origSpec.Copy()
container := spec.Task.GetContainer()
defaultContainer := Service.Task.GetContainer()
if container != nil {
if container.StopGracePeriod == nil {
container.StopGracePeriod = &gogotypes.Duration{}
deepcopy.Copy(con... | go | {
"resource": ""
} |
q32464 | CreateNetwork | train | func (s *Server) CreateNetwork(ctx context.Context, request *api.CreateNetworkRequest) (*api.CreateNetworkResponse, error) {
if err := validateNetworkSpec(request.Spec, s.pg); err != nil {
return nil, err
}
// TODO(mrjana): Consider using `Name` as a primary key to handle
// duplicate creations. See #65
n := &a... | go | {
"resource": ""
} |
q32465 | GetNetwork | train | func (s *Server) GetNetwork(ctx context.Context, request *api.GetNetworkRequest) (*api.GetNetworkResponse, error) {
if request.NetworkID == "" {
return nil, status.Errorf(codes.InvalidArgument, errInvalidArgument.Error())
}
var n *api.Network
s.store.View(func(tx store.ReadTx) {
n = store.GetNetwork(tx, reques... | go | {
"resource": ""
} |
q32466 | RemoveNetwork | train | func (s *Server) RemoveNetwork(ctx context.Context, request *api.RemoveNetworkRequest) (*api.RemoveNetworkResponse, error) {
if request.NetworkID == "" {
return nil, status.Errorf(codes.InvalidArgument, errInvalidArgument.Error())
}
var (
n *api.Network
rm = s.removeNetwork
)
s.store.View(func(tx store.Re... | go | {
"resource": ""
} |
q32467 | ListNetworks | train | func (s *Server) ListNetworks(ctx context.Context, request *api.ListNetworksRequest) (*api.ListNetworksResponse, error) {
var (
networks []*api.Network
err error
)
s.store.View(func(tx store.ReadTx) {
switch {
case request.Filters != nil && len(request.Filters.Names) > 0:
networks, err = store.FindN... | go | {
"resource": ""
} |
q32468 | start | train | func (s *session) start(ctx context.Context, description *api.NodeDescription) error {
log.G(ctx).Debugf("(*session).start")
errChan := make(chan error, 1)
var (
msg *api.SessionMessage
stream api.Dispatcher_SessionClient
err error
)
// Note: we don't defer cancellation of this context, because the
/... | go | {
"resource": ""
} |
q32469 | sendTaskStatus | train | func (s *session) sendTaskStatus(ctx context.Context, taskID string, taskStatus *api.TaskStatus) error {
client := api.NewDispatcherClient(s.conn.ClientConn)
if _, err := client.UpdateTaskStatus(ctx, &api.UpdateTaskStatusRequest{
SessionID: s.sessionID,
Updates: []*api.UpdateTaskStatusRequest_TaskStatusUpdate{
... | go | {
"resource": ""
} |
q32470 | sendError | train | func (s *session) sendError(err error) {
select {
case s.errs <- err:
case <-s.closed:
}
} | go | {
"resource": ""
} |
q32471 | close | train | func (s *session) close() error {
s.closeOnce.Do(func() {
s.cancel()
if s.conn != nil {
s.conn.Close(false)
}
close(s.closed)
})
return nil
} | go | {
"resource": ""
} |
q32472 | volumeCreateRequest | train | func (c *containerConfig) volumeCreateRequest(mount *api.Mount) *volume.VolumeCreateBody {
var (
driverName string
driverOpts map[string]string
labels map[string]string
)
if mount.VolumeOptions != nil && mount.VolumeOptions.DriverConfig != nil {
driverName = mount.VolumeOptions.DriverConfig.Name
drive... | go | {
"resource": ""
} |
q32473 | networks | train | func (c *containerConfig) networks() []string {
var networks []string
for name := range c.networksAttachments {
networks = append(networks, name)
}
return networks
} | go | {
"resource": ""
} |
q32474 | NewWALFactory | train | func NewWALFactory(encrypter encryption.Encrypter, decrypter encryption.Decrypter) WALFactory {
return walCryptor{
encrypter: encrypter,
decrypter: decrypter,
}
} | go | {
"resource": ""
} |
q32475 | Create | train | func (wc walCryptor) Create(dirpath string, metadata []byte) (WAL, error) {
w, err := wal.Create(dirpath, metadata)
if err != nil {
return nil, err
}
return &wrappedWAL{
WAL: w,
encrypter: wc.encrypter,
decrypter: wc.decrypter,
}, nil
} | go | {
"resource": ""
} |
q32476 | Open | train | func (wc walCryptor) Open(dirpath string, snap walpb.Snapshot) (WAL, error) {
w, err := wal.Open(dirpath, snap)
if err != nil {
return nil, err
}
return &wrappedWAL{
WAL: w,
encrypter: wc.encrypter,
decrypter: wc.decrypter,
}, nil
} | go | {
"resource": ""
} |
q32477 | ReadRepairWAL | train | func ReadRepairWAL(
ctx context.Context,
walDir string,
walsnap walpb.Snapshot,
factory WALFactory,
) (WAL, WALData, error) {
var (
reader WAL
metadata []byte
st raftpb.HardState
ents []raftpb.Entry
err error
)
repaired := false
for {
if reader, err = factory.Open(walDir, walsnap); ... | go | {
"resource": ""
} |
q32478 | Publish | train | func (fn LogPublisherFunc) Publish(ctx context.Context, message api.LogMessage) error {
return fn(ctx, message)
} | go | {
"resource": ""
} |
q32479 | Resolve | train | func Resolve(ctx context.Context, task *api.Task, executor Executor) (Controller, *api.TaskStatus, error) {
status := task.Status.Copy()
defer func() {
logStateChange(ctx, task.DesiredState, task.Status.State, status.State)
}()
ctlr, err := executor.Controller(task)
// depending on the tasks state, a failed c... | go | {
"resource": ""
} |
q32480 | CreateNode | train | func CreateNode(tx Tx, n *api.Node) error {
return tx.create(tableNode, n)
} | go | {
"resource": ""
} |
q32481 | UpdateNode | train | func UpdateNode(tx Tx, n *api.Node) error {
return tx.update(tableNode, n)
} | go | {
"resource": ""
} |
q32482 | DeleteNode | train | func DeleteNode(tx Tx, id string) error {
return tx.delete(tableNode, id)
} | go | {
"resource": ""
} |
q32483 | GetNode | train | func GetNode(tx ReadTx, id string) *api.Node {
n := tx.get(tableNode, id)
if n == nil {
return nil
}
return n.(*api.Node)
} | go | {
"resource": ""
} |
q32484 | FindNodes | train | func FindNodes(tx ReadTx, by By) ([]*api.Node, error) {
checkType := func(by By) error {
switch by.(type) {
case byName, byNamePrefix, byIDPrefix, byRole, byMembership, byCustom, byCustomPrefix:
return nil
default:
return ErrInvalidFindBy
}
}
nodeList := []*api.Node{}
appendResult := func(o api.Store... | go | {
"resource": ""
} |
q32485 | Start | train | func (s *Server) Start(ctx context.Context) error {
s.mu.Lock()
defer s.mu.Unlock()
if s.cancelAll != nil {
return errAlreadyRunning
}
s.pctx, s.cancelAll = context.WithCancel(ctx)
return nil
} | go | {
"resource": ""
} |
q32486 | Stop | train | func (s *Server) Stop() error {
s.mu.Lock()
defer s.mu.Unlock()
if s.cancelAll == nil {
return errNotRunning
}
s.cancelAll()
s.cancelAll = nil
return nil
} | go | {
"resource": ""
} |
q32487 | UpdateKEK | train | func (r RaftDEKData) UpdateKEK(oldKEK, candidateKEK ca.KEKData) ca.PEMKeyHeaders {
if _, unlockedToLocked, err := compareKEKs(oldKEK, candidateKEK); err == nil && unlockedToLocked {
return RaftDEKData{
EncryptionKeys: r.EncryptionKeys,
NeedsRotation: true,
FIPS: r.FIPS,
}
}
return r
} | go | {
"resource": ""
} |
q32488 | NewRaftDEKManager | train | func NewRaftDEKManager(kw ca.KeyWriter, fips bool) (*RaftDEKManager, error) {
// If there is no current DEK, generate one and write it to disk
err := kw.ViewAndUpdateHeaders(func(h ca.PEMKeyHeaders) (ca.PEMKeyHeaders, error) {
dekData, ok := h.(RaftDEKData)
// it wasn't a raft DEK manager before - just replace it... | go | {
"resource": ""
} |
q32489 | NeedsRotation | train | func (r *RaftDEKManager) NeedsRotation() bool {
h, _ := r.kw.GetCurrentState()
data, ok := h.(RaftDEKData)
if !ok {
return false
}
return data.NeedsRotation || data.EncryptionKeys.PendingDEK != nil
} | go | {
"resource": ""
} |
q32490 | GetKeys | train | func (r *RaftDEKManager) GetKeys() raft.EncryptionKeys {
var newKeys, originalKeys raft.EncryptionKeys
err := r.kw.ViewAndUpdateHeaders(func(h ca.PEMKeyHeaders) (ca.PEMKeyHeaders, error) {
data, ok := h.(RaftDEKData)
if !ok {
return nil, errNotUsingRaftDEKData
}
originalKeys = data.EncryptionKeys
if !dat... | go | {
"resource": ""
} |
q32491 | UpdateKeys | train | func (r *RaftDEKManager) UpdateKeys(newKeys raft.EncryptionKeys) error {
return r.kw.ViewAndUpdateHeaders(func(h ca.PEMKeyHeaders) (ca.PEMKeyHeaders, error) {
data, ok := h.(RaftDEKData)
if !ok {
return nil, errNotUsingRaftDEKData
}
// If there is no current DEK, we are basically wiping out all DEKs (no hea... | go | {
"resource": ""
} |
q32492 | MaybeUpdateKEK | train | func (r *RaftDEKManager) MaybeUpdateKEK(candidateKEK ca.KEKData) (bool, bool, error) {
var updated, unlockedToLocked bool
err := r.kw.ViewAndRotateKEK(func(currentKEK ca.KEKData, h ca.PEMKeyHeaders) (ca.KEKData, ca.PEMKeyHeaders, error) {
var err error
updated, unlockedToLocked, err = compareKEKs(currentKEK, cand... | go | {
"resource": ""
} |
q32493 | Listen | train | func (c *Collector) Listen(port int) error {
var err error
c.ln, err = net.Listen("tcp", ":"+strconv.Itoa(port))
return err
} | go | {
"resource": ""
} |
q32494 | Collect | train | func (c *Collector) Collect(ctx context.Context, count uint64) {
start := time.Now()
for i := uint64(0); i < count; i++ {
conn, err := c.ln.Accept()
if err != nil {
log.G(ctx).WithError(err).Error("failure accepting connection")
continue
}
c.t.UpdateSince(start)
conn.Close()
}
} | go | {
"resource": ""
} |
q32495 | Stats | train | func (c *Collector) Stats(w io.Writer, unit time.Duration) {
du := float64(unit)
duSuffix := unit.String()[1:]
t := c.t.Snapshot()
ps := t.Percentiles([]float64{0.5, 0.75, 0.95, 0.99, 0.999})
fmt.Fprintln(w, "stats:")
fmt.Fprintf(w, " count: %9d\n", t.Count())
fmt.Fprintf(w, " min: %12.2f%s\n",... | go | {
"resource": ""
} |
q32496 | Less | train | func (is slotsByRunningState) Less(i, j int) bool {
iRunning := false
jRunning := false
for _, ii := range is[i] {
if ii.Status.State == api.TaskStateRunning {
iRunning = true
break
}
}
for _, ij := range is[j] {
if ij.Status.State == api.TaskStateRunning {
jRunning = true
break
}
}
if iRun... | go | {
"resource": ""
} |
q32497 | updatableAndDeadSlots | train | func (r *Orchestrator) updatableAndDeadSlots(ctx context.Context, service *api.Service) (map[uint64]orchestrator.Slot, map[uint64]orchestrator.Slot, error) {
var (
tasks []*api.Task
err error
)
r.store.View(func(tx store.ReadTx) {
tasks, err = store.FindTasks(tx, store.ByServiceID(service.ID))
})
if err !=... | go | {
"resource": ""
} |
q32498 | SlotTuple | train | func (r *Orchestrator) SlotTuple(t *api.Task) orchestrator.SlotTuple {
return orchestrator.SlotTuple{
ServiceID: t.ServiceID,
Slot: t.Slot,
}
} | go | {
"resource": ""
} |
q32499 | CreateCluster | train | func CreateCluster(tx Tx, c *api.Cluster) error {
// Ensure the name is not already in use.
if tx.lookup(tableCluster, indexName, strings.ToLower(c.Spec.Annotations.Name)) != nil {
return ErrNameConflict
}
return tx.create(tableCluster, c)
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.