_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q27500 | AddJob | train | func (c *Host) AddJob(job *host.Job) error {
return c.c.Put(fmt.Sprintf("/host/jobs/%s", job.ID), job, nil)
} | go | {
"resource": ""
} |
q27501 | GetJob | train | func (c *Host) GetJob(id string) (*host.ActiveJob, error) {
var res host.ActiveJob
err := c.c.Get(fmt.Sprintf("/host/jobs/%s", id), &res)
return &res, err
} | go | {
"resource": ""
} |
q27502 | StopJob | train | func (c *Host) StopJob(id string) error {
return c.c.Delete(fmt.Sprintf("/host/jobs/%s", id))
} | go | {
"resource": ""
} |
q27503 | SignalJob | train | func (c *Host) SignalJob(id string, sig int) error {
return c.c.Put(fmt.Sprintf("/host/jobs/%s/signal/%d", id, sig), nil, nil)
} | go | {
"resource": ""
} |
q27504 | DiscoverdDeregisterJob | train | func (c *Host) DiscoverdDeregisterJob(id string) error {
return c.c.Put(fmt.Sprintf("/host/jobs/%s/discoverd-deregister", id), nil, nil)
} | go | {
"resource": ""
} |
q27505 | StreamEvents | train | func (c *Host) StreamEvents(id string, ch chan *host.Event) (stream.Stream, error) {
r := fmt.Sprintf("/host/jobs/%s", id)
if id == "all" {
r = "/host/jobs"
}
return c.c.ResumingStream("GET", r, ch)
} | go | {
"resource": ""
} |
q27506 | CreateVolume | train | func (c *Host) CreateVolume(providerId string, info *volume.Info) error {
return c.c.Post(fmt.Sprintf("/storage/providers/%s/volumes", providerId), info, info)
} | go | {
"resource": ""
} |
q27507 | GetVolume | train | func (c *Host) GetVolume(volumeID string) (*volume.Info, error) {
var volume volume.Info
return &volume, c.c.Get(fmt.Sprintf("/storage/volumes/%s", volumeID), &volume)
} | go | {
"resource": ""
} |
q27508 | ListVolumes | train | func (c *Host) ListVolumes() ([]*volume.Info, error) {
var volumes []*volume.Info
return volumes, c.c.Get("/storage/volumes", &volumes)
} | go | {
"resource": ""
} |
q27509 | StreamVolumes | train | func (c *Host) StreamVolumes(ch chan *volume.Event) (stream.Stream, error) {
return c.c.ResumingStream("GET", "/storage/volumes", ch)
} | go | {
"resource": ""
} |
q27510 | DestroyVolume | train | func (c *Host) DestroyVolume(volumeID string) error {
return c.c.Delete(fmt.Sprintf("/storage/volumes/%s", volumeID))
} | go | {
"resource": ""
} |
q27511 | CreateSnapshot | train | func (c *Host) CreateSnapshot(volumeID string) (*volume.Info, error) {
var res volume.Info
err := c.c.Put(fmt.Sprintf("/storage/volumes/%s/snapshot", volumeID), nil, &res)
return &res, err
} | go | {
"resource": ""
} |
q27512 | PullSnapshot | train | func (c *Host) PullSnapshot(receiveVolID string, sourceHostID string, sourceSnapID string) (*volume.Info, error) {
var res volume.Info
pull := volume.PullCoordinate{
HostID: sourceHostID,
SnapshotID: sourceSnapID,
}
err := c.c.Post(fmt.Sprintf("/storage/volumes/%s/pull_snapshot", receiveVolID), pull, &res)
... | go | {
"resource": ""
} |
q27513 | PullImages | train | func (c *Host) PullImages(repository, configDir, version string, tufDB io.Reader, ch chan *ct.ImagePullInfo) (stream.Stream, error) {
header := http.Header{"Content-Type": {"application/octet-stream"}}
query := make(url.Values)
query.Set("repository", repository)
query.Set("config-dir", configDir)
query.Set("versi... | go | {
"resource": ""
} |
q27514 | PullBinariesAndConfig | train | func (c *Host) PullBinariesAndConfig(repository, binDir, configDir, version string, tufDB io.Reader) (map[string]string, error) {
query := make(url.Values)
query.Set("repository", repository)
query.Set("bin-dir", binDir)
query.Set("config-dir", configDir)
query.Set("version", version)
path := "/host/pull/binaries... | go | {
"resource": ""
} |
q27515 | proxyWhitelisted | train | func proxyWhitelisted(r *http.Request) bool {
for _, url := range []string{"/raft/promote", "/raft/demote", "/shutdown"} {
if strings.HasPrefix(r.URL.Path, url) {
return true
}
}
return false
} | go | {
"resource": ""
} |
q27516 | servePutService | train | func (h *Handler) servePutService(w http.ResponseWriter, r *http.Request, params httprouter.Params) {
// Retrieve the path parameter.
service := params.ByName("service")
if err := ValidServiceName(service); err != nil {
hh.ValidationError(w, "", err.Error())
return
}
// Read config from the request.
config :... | go | {
"resource": ""
} |
q27517 | serveDeleteService | train | func (h *Handler) serveDeleteService(w http.ResponseWriter, r *http.Request, params httprouter.Params) {
// Retrieve the path parameter.
service := params.ByName("service")
if err := ValidServiceName(service); err != nil {
hh.ValidationError(w, "", err.Error())
return
}
// Delete from the store.
if err := h.... | go | {
"resource": ""
} |
q27518 | serveGetService | train | func (h *Handler) serveGetService(w http.ResponseWriter, r *http.Request, params httprouter.Params) {
// This should only return a stream if the Accept header is
// text/event-stream (and return a 406 otherwise), but we
// always return a stream due to Go's http.Client not
// maintaining headers through a redirect.... | go | {
"resource": ""
} |
q27519 | servePutServiceMeta | train | func (h *Handler) servePutServiceMeta(w http.ResponseWriter, r *http.Request, params httprouter.Params) {
// Read the metadata from the request.
meta := &discoverd.ServiceMeta{}
if err := hh.DecodeJSON(r, meta); err != nil {
hh.Error(w, err)
return
}
// Update the meta in the store.
if err := h.Store.SetServ... | go | {
"resource": ""
} |
q27520 | serveGetServiceMeta | train | func (h *Handler) serveGetServiceMeta(w http.ResponseWriter, r *http.Request, params httprouter.Params) {
// Read path parameter.
service := params.ByName("service")
// Read meta from the store.
meta := h.Store.ServiceMeta(service)
if meta == nil {
hh.ObjectNotFoundError(w, "service meta not found")
return
}... | go | {
"resource": ""
} |
q27521 | servePutInstance | train | func (h *Handler) servePutInstance(w http.ResponseWriter, r *http.Request, params httprouter.Params) {
// Read path parameter.
service := params.ByName("service")
// Read instance from request.
inst := &discoverd.Instance{}
if err := json.NewDecoder(r.Body).Decode(inst); err != nil {
hh.Error(w, err)
return
... | go | {
"resource": ""
} |
q27522 | serveDeleteInstance | train | func (h *Handler) serveDeleteInstance(w http.ResponseWriter, r *http.Request, params httprouter.Params) {
// Retrieve path parameters.
service := params.ByName("service")
instanceID := params.ByName("instance_id")
// Remove instance from the store.
if err := h.Store.RemoveInstance(service, instanceID); err == Err... | go | {
"resource": ""
} |
q27523 | serveGetInstances | train | func (h *Handler) serveGetInstances(w http.ResponseWriter, r *http.Request, params httprouter.Params) {
// If the client is requesting a stream, then handle as a stream.
if strings.Contains(r.Header.Get("Accept"), "text/event-stream") {
h.serveStream(w, params, discoverd.EventKindUp|discoverd.EventKindUpdate|discov... | go | {
"resource": ""
} |
q27524 | servePutLeader | train | func (h *Handler) servePutLeader(w http.ResponseWriter, r *http.Request, params httprouter.Params) {
// Retrieve path parameters.
service := params.ByName("service")
// Check if the service allows manual leader election.
config := h.Store.Config(service)
if config == nil || config.LeaderType != discoverd.LeaderTy... | go | {
"resource": ""
} |
q27525 | serveGetLeader | train | func (h *Handler) serveGetLeader(w http.ResponseWriter, r *http.Request, params httprouter.Params) {
// Process as a stream if that's what the client wants.
if strings.Contains(r.Header.Get("Accept"), "text/event-stream") {
h.serveStream(w, params, discoverd.EventKindLeader)
return
}
// Otherwise retrieve the ... | go | {
"resource": ""
} |
q27526 | servePromote | train | func (h *Handler) servePromote(w http.ResponseWriter, r *http.Request, params httprouter.Params) {
if err := h.Main.Promote(); err != nil {
hh.Error(w, err)
return
}
} | go | {
"resource": ""
} |
q27527 | serveDemote | train | func (h *Handler) serveDemote(w http.ResponseWriter, r *http.Request, params httprouter.Params) {
if err := h.Main.Demote(); err != nil {
hh.Error(w, err)
return
}
} | go | {
"resource": ""
} |
q27528 | serveStream | train | func (h *Handler) serveStream(w http.ResponseWriter, params httprouter.Params, kind discoverd.EventKind) {
// Create a buffered channel to receive events.
ch := make(chan *discoverd.Event, StreamBufferSize)
// Subscribe to events on the store.
service := params.ByName("service")
stream := h.Store.Subscribe(servic... | go | {
"resource": ""
} |
q27529 | serveGetRaftLeader | train | func (h *Handler) serveGetRaftLeader(w http.ResponseWriter, r *http.Request, params httprouter.Params) {
leader := h.Store.Leader()
if leader == "" {
hh.ServiceUnavailableError(w, ErrNoKnownLeader.Error())
return
}
hh.JSON(w, 200, dt.RaftLeader{Host: h.Store.Leader()})
} | go | {
"resource": ""
} |
q27530 | serveGetRaftPeers | train | func (h *Handler) serveGetRaftPeers(w http.ResponseWriter, r *http.Request, params httprouter.Params) {
peers, err := h.Store.GetPeers()
if err != nil {
hh.Error(w, err)
}
hh.JSON(w, 200, peers)
} | go | {
"resource": ""
} |
q27531 | servePutRaftPeer | train | func (h *Handler) servePutRaftPeer(w http.ResponseWriter, r *http.Request, params httprouter.Params) {
peer := params.ByName("peer")
if err := h.Store.AddPeer(peer); err == ErrNotLeader {
h.redirectToLeader(w, r)
return
} else if err != nil {
hh.Error(w, err)
return
}
var targetLogIndex dt.TargetLogIndex
... | go | {
"resource": ""
} |
q27532 | serveDeleteRaftPeer | train | func (h *Handler) serveDeleteRaftPeer(w http.ResponseWriter, r *http.Request, params httprouter.Params) {
peer := params.ByName("peer")
if err := h.Store.RemovePeer(peer); err == ErrNotLeader {
h.redirectToLeader(w, r)
return
} else if err != nil {
hh.Error(w, err)
return
}
} | go | {
"resource": ""
} |
q27533 | redirectToLeader | train | func (h *Handler) redirectToLeader(w http.ResponseWriter, r *http.Request) {
// Find the current leader.
leader := h.Store.Leader()
if leader == "" {
hh.ServiceUnavailableError(w, ErrNoKnownLeader.Error())
return
}
redirectToHost(w, r, leader)
} | go | {
"resource": ""
} |
q27534 | NewStore | train | func NewStore(path string) *Store {
return &Store{
path: path,
data: newRaftData(),
subscribers: make(map[string]*list.List),
leaderCh: make(chan bool),
heartbeats: make(map[instanceKey]time.Time),
closing: make(chan struct{}),
HeartbeatTimeout: 1000 * time.Millisecond,
ElectionTim... | go | {
"resource": ""
} |
q27535 | Open | train | func (s *Store) Open() error {
s.mu.Lock()
defer s.mu.Unlock()
// Set up logging.
s.logger = log.New(s.LogOutput, "[discoverd] ", log.LstdFlags)
// Require listener & advertise address.
if s.Listener == nil {
return ErrListenerRequired
} else if s.Advertise == nil {
return ErrAdvertiseRequired
}
// Crea... | go | {
"resource": ""
} |
q27536 | Close | train | func (s *Store) Close() (lastIdx uint64, err error) {
// Notify goroutines of closing and wait until they finish.
close(s.closing)
s.wg.Wait()
s.mu.Lock()
defer s.mu.Unlock()
for _, l := range s.subscribers {
for el := l.Front(); el != nil; el = el.Next() {
go el.Value.(*subscription).Close()
}
}
if s.r... | go | {
"resource": ""
} |
q27537 | Leader | train | func (s *Store) Leader() string {
if s.raft == nil {
return ""
}
return s.raft.Leader()
} | go | {
"resource": ""
} |
q27538 | monitorLeaderCh | train | func (s *Store) monitorLeaderCh() {
defer s.wg.Done()
incoming := s.raft.LeaderCh()
for {
select {
case <-s.closing:
return
case isLeader, ok := <-incoming:
// Update leader time and clear heartbeats.
s.mu.Lock()
if isLeader {
s.leaderTime = time.Now()
} else {
s.leaderTime = time.Time{... | go | {
"resource": ""
} |
q27539 | LeaderCh | train | func (s *Store) LeaderCh() <-chan bool {
if s.raft == nil {
ch := make(chan bool, 1)
ch <- true
return ch
}
return s.leaderCh
} | go | {
"resource": ""
} |
q27540 | AddPeer | train | func (s *Store) AddPeer(peer string) error {
err := s.raft.AddPeer(peer).Error()
if err == raft.ErrNotLeader {
err = ErrNotLeader
} else if err == raft.ErrKnownPeer {
return nil
}
return err
} | go | {
"resource": ""
} |
q27541 | RemovePeer | train | func (s *Store) RemovePeer(peer string) error {
err := s.raft.RemovePeer(peer).Error()
if err == raft.ErrNotLeader {
err = ErrNotLeader
} else if err == raft.ErrUnknownPeer {
return nil
}
return err
} | go | {
"resource": ""
} |
q27542 | SetPeers | train | func (s *Store) SetPeers(peers []string) error {
return s.raft.SetPeers(peers).Error()
} | go | {
"resource": ""
} |
q27543 | ServiceNames | train | func (s *Store) ServiceNames() []string {
s.mu.RLock()
defer s.mu.RUnlock()
var a []string
for name := range s.data.Services {
a = append(a, name)
}
sort.Strings(a)
return a
} | go | {
"resource": ""
} |
q27544 | AddService | train | func (s *Store) AddService(service string, config *discoverd.ServiceConfig) error {
if config == nil {
config = DefaultServiceConfig
}
// Serialize command.
cmd, err := json.Marshal(&addServiceCommand{
Service: service,
Config: config,
})
if err != nil {
return err
}
if _, err := s.raftApply(addServi... | go | {
"resource": ""
} |
q27545 | Config | train | func (s *Store) Config(service string) *discoverd.ServiceConfig {
s.mu.RLock()
defer s.mu.RUnlock()
return s.data.Services[service]
} | go | {
"resource": ""
} |
q27546 | RemoveService | train | func (s *Store) RemoveService(service string) error {
// Serialize command.
cmd, err := json.Marshal(&removeServiceCommand{Service: service})
if err != nil {
return err
}
if _, err := s.raftApply(removeServiceCommandType, cmd); err != nil {
return err
}
return nil
} | go | {
"resource": ""
} |
q27547 | Instances | train | func (s *Store) Instances(service string) ([]*discoverd.Instance, error) {
s.mu.Lock()
defer s.mu.Unlock()
return s.instances(service), nil
} | go | {
"resource": ""
} |
q27548 | ServiceMeta | train | func (s *Store) ServiceMeta(service string) *discoverd.ServiceMeta {
s.mu.Lock()
defer s.mu.Unlock()
return s.serviceMeta(service)
} | go | {
"resource": ""
} |
q27549 | SetServiceLeader | train | func (s *Store) SetServiceLeader(service, id string) error {
// Serialize command.
cmd, err := json.Marshal(&setLeaderCommand{
Service: service,
ID: id,
})
if err != nil {
return err
}
if _, err := s.raftApply(setLeaderCommandType, cmd); err != nil {
return err
}
return nil
} | go | {
"resource": ""
} |
q27550 | invalidateServiceLeader | train | func (s *Store) invalidateServiceLeader(service string) {
// Retrieve service config.
c := s.data.Services[service]
// Ignore if there is no config or the leader is manually elected.
if c == nil || c.LeaderType == discoverd.LeaderTypeManual {
return
}
// Retrieve current leader ID.
prevLeaderID := s.data.Lea... | go | {
"resource": ""
} |
q27551 | expirer | train | func (s *Store) expirer() {
defer s.wg.Done()
ticker := time.NewTicker(s.ExpiryCheckInterval)
defer ticker.Stop()
for {
// Wait for next check or for close signal.
select {
case <-s.closing:
return
case <-ticker.C:
}
// Check all instances for expiration.
if err := s.EnforceExpiry(); err != nil ... | go | {
"resource": ""
} |
q27552 | EnforceExpiry | train | func (s *Store) EnforceExpiry() error {
var cmd []byte
if err := func() error {
s.mu.Lock()
defer s.mu.Unlock()
// Ignore if this store is not the leader and hasn't been for at least 2 TTLs intervals.
if !s.IsLeader() {
return raft.ErrNotLeader
} else if s.leaderTime.IsZero() || time.Since(s.leaderTime)... | go | {
"resource": ""
} |
q27553 | raftApply | train | func (s *Store) raftApply(typ byte, cmd []byte) (uint64, error) {
s.mu.RLock()
if s.raft == nil {
s.mu.RUnlock()
return 0, ErrShutdown
}
s.mu.RUnlock()
// Join the command type and data into one message.
buf := append([]byte{typ}, cmd...)
// Apply to raft and receive an ApplyFuture back.
f := s.raft.Apply... | go | {
"resource": ""
} |
q27554 | Snapshot | train | func (s *Store) Snapshot() (raft.FSMSnapshot, error) {
s.mu.Lock()
defer s.mu.Unlock()
buf, err := json.Marshal(s.data)
if err != nil {
return nil, err
}
return &raftSnapshot{data: buf}, nil
} | go | {
"resource": ""
} |
q27555 | Restore | train | func (s *Store) Restore(r io.ReadCloser) error {
s.mu.Lock()
defer s.mu.Unlock()
data := &raftData{}
if err := json.NewDecoder(r).Decode(data); err != nil {
return err
}
s.data = data
return nil
} | go | {
"resource": ""
} |
q27556 | Subscribe | train | func (s *Store) Subscribe(service string, sendCurrent bool, kinds discoverd.EventKind, ch chan *discoverd.Event) stream.Stream {
s.mu.Lock()
defer s.mu.Unlock()
// Create service subscription list if it doesn't exist yet.
if _, ok := s.subscribers[service]; !ok {
s.subscribers[service] = list.New()
}
// Creat... | go | {
"resource": ""
} |
q27557 | broadcast | train | func (s *Store) broadcast(event *discoverd.Event) {
logBroadcast(event)
// Retrieve list of subscribers for the service.
l, ok := s.subscribers[event.Service]
if !ok {
return
}
// Iterate over each subscriber in the list.
for el := l.Front(); el != nil; el = el.Next() {
sub := el.Value.(*subscription)
... | go | {
"resource": ""
} |
q27558 | Persist | train | func (ss *raftSnapshot) Persist(sink raft.SnapshotSink) error {
// Write data to sink.
if _, err := sink.Write(ss.data); err != nil {
sink.Cancel()
return err
}
// Close and exit.
return sink.Close()
} | go | {
"resource": ""
} |
q27559 | ServiceInstances | train | func (d *raftData) ServiceInstances(service string) []*discoverd.Instance {
a := make([]*discoverd.Instance, 0, len(d.Instances[service]))
for _, i := range d.Instances[service] {
a = append(a, i)
}
sort.Sort(instanceSlice(a))
return a
} | go | {
"resource": ""
} |
q27560 | ValidServiceName | train | func ValidServiceName(service string) error {
// Blank service names are not allowed.
if service == "" {
return ErrUnsetService
}
// Service names must consist of the characters [a-z0-9-]
for _, r := range service {
if (r < 'a' || r > 'z') && (r < '0' || r > '9') && r != '-' {
return ErrInvalidService
}
... | go | {
"resource": ""
} |
q27561 | Instances | train | func (s *ProxyStore) Instances(service string) ([]*discoverd.Instance, error) {
host := s.Peers[rand.Intn(len(s.Peers))]
client := discoverd.NewClientWithURL("http://" + host)
return client.Service(service).Instances()
} | go | {
"resource": ""
} |
q27562 | newRaftLayer | train | func newRaftLayer(ln net.Listener, addr net.Addr) *raftLayer {
return &raftLayer{
ln: ln,
addr: addr,
}
} | go | {
"resource": ""
} |
q27563 | CloseStream | train | func (c *Call) CloseStream() error {
if !c.Stream {
return errors.New("rpc: cannot close non-stream request")
}
<-c.sent
c.client.sending.Lock()
defer c.client.sending.Unlock()
c.client.mutex.Lock()
if c.client.shutdown {
c.client.mutex.Unlock()
return ErrShutdown
}
c.client.mutex.Unlock()
c.client.re... | go | {
"resource": ""
} |
q27564 | NewClient | train | func NewClient(conn io.ReadWriteCloser) *Client {
encBuf := bufio.NewWriter(conn)
client := &gobClientCodec{conn, gob.NewDecoder(conn), gob.NewEncoder(encBuf), encBuf}
return NewClientWithCodec(client)
} | go | {
"resource": ""
} |
q27565 | DialHTTP | train | func DialHTTP(network, address string) (*Client, error) {
return DialHTTPPath(network, address, DefaultRPCPath, nil)
} | go | {
"resource": ""
} |
q27566 | DialHTTPPath | train | func DialHTTPPath(network, address, path string, dial DialFunc) (*Client, error) {
if dial == nil {
dial = net.Dial
}
var err error
conn, err := dial(network, address)
if err != nil {
return nil, err
}
client, err := NewHTTPClient(conn, path, nil)
if err != nil {
conn.Close()
return nil, &net.OpError{
... | go | {
"resource": ""
} |
q27567 | Dial | train | func Dial(network, address string) (*Client, error) {
conn, err := net.Dial(network, address)
if err != nil {
return nil, err
}
return NewClient(conn), nil
} | go | {
"resource": ""
} |
q27568 | StreamGo | train | func (client *Client) StreamGo(serviceMethod string, args interface{}, replyStream interface{}) *Call {
// first check the replyStream object is a stream of pointers to a data structure
typ := reflect.TypeOf(replyStream)
// FIXME: check the direction of the channel, maybe?
if typ.Kind() != reflect.Chan || typ.Elem(... | go | {
"resource": ""
} |
q27569 | String | train | func (dsn *DSN) String() string {
u := url.URL{
Host: fmt.Sprintf("tcp(%s)", dsn.Host),
Path: "/" + dsn.Database,
RawQuery: url.Values{
"timeout": {dsn.Timeout.String()},
}.Encode(),
}
// Set password, if available.
if dsn.Password == "" {
u.User = url.User(dsn.User)
} else {
u.User = url.UserPassw... | go | {
"resource": ""
} |
q27570 | pingLeases | train | func pingLeases(leases []subnet.SubnetLease) error {
const workers = 5
const timeout = 1 * time.Second
if len(leases) == 0 {
return nil
}
work := make(chan subnet.SubnetLease)
results := make(chan bool, workers)
client := http.Client{Timeout: timeout}
var wg sync.WaitGroup
wg.Add(workers)
for i := 0; i <... | go | {
"resource": ""
} |
q27571 | migrateProcessData | train | func migrateProcessData(tx *postgres.DBTx) error {
type Release struct {
ID string
// use map[string]interface{} for process types so we can just
// update Volumes and Data and leave other fields untouched
Processes map[string]map[string]interface{}
}
var releases []Release
rows, err := tx.Query("SELECT r... | go | {
"resource": ""
} |
q27572 | Finalize | train | func (r *RequestTrace) Finalize(backend *router.Backend) {
r.mtx.Lock()
r.final = true
r.Backend = backend
r.mtx.Unlock()
} | go | {
"resource": ""
} |
q27573 | traceRequest | train | func traceRequest(req *http.Request) (*http.Request, *RequestTrace) {
trace := &RequestTrace{}
ct := &httptrace.ClientTrace{
GetConn: func(hostPort string) {
trace.mtx.Lock()
defer trace.mtx.Unlock()
if trace.final {
return
}
trace.ConnectStart = time.Now()
},
GotConn: func(info httptrace.Got... | go | {
"resource": ""
} |
q27574 | execWithRetries | train | func (c *context) execWithRetries(query string, args ...interface{}) error {
return execAttempts.Run(func() error {
return c.db.Exec(query, args...)
})
} | go | {
"resource": ""
} |
q27575 | UnmarshalBinary | train | func UnmarshalBinary(b []byte) (interface{}, error) {
if len(b) < 1 {
return nil, fmt.Errorf("compare: buffer to unmarshal is zero-length")
}
switch Type(b[0]) {
case TypeFalse, TypeTrue:
v := new(Bool)
return *v, v.UnmarshalBinary(b)
case TypeIntegers:
v := new(Integers)
return *v, v.UnmarshalBinary(b)
... | go | {
"resource": ""
} |
q27576 | Bytes | train | func Bytes(m *rfc5424.Message) []byte {
msg := m.Bytes()
return bytes.Join([][]byte{[]byte(strconv.Itoa(len(msg))), msg}, []byte{' '})
} | go | {
"resource": ""
} |
q27577 | Split | train | func Split(data []byte, atEOF bool) (advance int, token []byte, err error) {
return split(false, data, atEOF)
} | go | {
"resource": ""
} |
q27578 | SplitWithNewlines | train | func SplitWithNewlines(data []byte, atEOF bool) (advance int, token []byte, err error) {
return split(true, data, atEOF)
} | go | {
"resource": ""
} |
q27579 | CloseNotifyConn | train | func CloseNotifyConn(conn net.Conn) net.Conn {
pr, pw := io.Pipe()
c := &closeNotifyConn{
Conn: conn,
r: pr,
cnc: make(chan bool),
}
go func() {
_, err := io.Copy(pw, conn)
if err == nil {
err = io.EOF
}
pw.CloseWithError(err)
close(c.cnc)
}()
return c
} | go | {
"resource": ""
} |
q27580 | Decode | train | func (dec *Decoder) Decode(v interface{}) error {
data, err := dec.Reader.Read()
if err != nil {
return err
}
return json.Unmarshal(data, v)
} | go | {
"resource": ""
} |
q27581 | WatchSubnets | train | func (r *registry) WatchSubnets(since uint64, stop chan bool) (*subnet.Response, error) {
for {
select {
case event, ok := <-r.events:
if !ok {
return nil, errors.New("unexpected close of discoverd event stream")
}
if event.Kind != discoverd.EventKindServiceMeta {
continue
}
net := &Network{... | go | {
"resource": ""
} |
q27582 | newLogger | train | func newLogger(tty bool, file string, verbose bool) log15.Logger {
stdoutFormat := log15.LogfmtFormat()
if tty {
stdoutFormat = log15.TerminalFormat()
}
stdoutHandler := log15.StreamHandler(os.Stdout, stdoutFormat)
if !verbose {
stdoutHandler = log15.LvlFilterHandler(log15.LvlInfo, stdoutHandler)
}
log := lo... | go | {
"resource": ""
} |
q27583 | NewProgressBar | train | func NewProgressBar(count int, tty bool) (*pb.ProgressBar, error) {
bar := pb.New(count)
if !tty {
bar.Output = os.Stderr
return bar, nil
}
// replace os.Stdout / os.Stderr with a pipe and copy output to a
// channel so that the progress bar can be wiped before printing output
type stdOutput struct {
Out ... | go | {
"resource": ""
} |
q27584 | GetVersion | train | func GetVersion(client *tuf.Client, name string) (string, error) {
targets, err := client.Targets()
if err != nil {
return "", err
}
target, ok := targets[name]
if !ok {
return "", fmt.Errorf("missing %q in tuf targets", name)
}
if target.Custom == nil || len(*target.Custom) == 0 {
return "", errors.New("m... | go | {
"resource": ""
} |
q27585 | IsRetryableError | train | func IsRetryableError(err error) bool {
e, ok := err.(JSONError)
return ok && e.Retry
} | go | {
"resource": ""
} |
q27586 | evalLater | train | func (p *Peer) evalLater(delay time.Duration) {
if p.retryCh != nil {
p.retryCh <- struct{}{}
return
}
time.AfterFunc(delay, p.triggerEval)
} | go | {
"resource": ""
} |
q27587 | startTransitionToNormalMode | train | func (p *Peer) startTransitionToNormalMode() {
log := p.log.New("fn", "startTransitionToNormalMode")
if p.Info().State.Primary.Meta[p.idKey] != p.id || p.Info().Role != RolePrimary {
panic("startTransitionToNormalMode called when not primary")
}
// In the normal takeover case, we'd pick an async. In this case, w... | go | {
"resource": ""
} |
q27588 | applyConfig | train | func (p *Peer) applyConfig() (err error) {
p.moving()
log := p.log.New("fn", "applyConfig")
if p.online == nil {
panic("applyConfig with database in unknown state")
}
config := p.Config()
if p.applied != nil && p.applied.Equal(config) && p.applied.State.Equal(config.State) {
log.Info("skipping config apply,... | go | {
"resource": ""
} |
q27589 | whichAsync | train | func (p *Peer) whichAsync() int {
for i, a := range p.Info().State.Async {
if p.id == a.Meta[p.idKey] {
return i
}
}
return -1
} | go | {
"resource": ""
} |
q27590 | lookupUpstream | train | func (p *Peer) lookupUpstream(whichAsync int) *discoverd.Instance {
if whichAsync == 0 {
return p.Info().State.Sync
}
return p.Info().State.Async[whichAsync-1]
} | go | {
"resource": ""
} |
q27591 | lookupDownstream | train | func (p *Peer) lookupDownstream(whichAsync int) *discoverd.Instance {
async := p.Info().State.Async
if whichAsync == len(async)-1 {
return nil
}
return async[whichAsync+1]
} | go | {
"resource": ""
} |
q27592 | peerIsPresent | train | func (p *Peer) peerIsPresent(other *discoverd.Instance) bool {
// We should never even be asking whether we're present. If we need to do
// this at some point in the future, we need to consider we should always
// consider ourselves present or whether we should check the list.
if other.Meta[p.idKey] == p.id {
pan... | go | {
"resource": ""
} |
q27593 | NewReverseProxy | train | func NewReverseProxy(bf BackendListFunc, stickyKey *[32]byte, sticky bool, rt RequestTracker, l log15.Logger) *ReverseProxy {
return &ReverseProxy{
transport: &transport{
getBackends: bf,
stickyCookieKey: stickyKey,
useStickySessions: sticky,
},
FlushInterval: 10 * time.Millisecond,
RequestTr... | go | {
"resource": ""
} |
q27594 | ServeConn | train | func (p *ReverseProxy) ServeConn(ctx context.Context, dconn net.Conn) {
transport := p.transport
if transport == nil {
panic("router: nil transport for proxy")
}
defer dconn.Close()
clientGone := dconn.(http.CloseNotifier).CloseNotify()
ctx, cancel := context.WithCancel(ctx)
defer cancel() // finish cancellat... | go | {
"resource": ""
} |
q27595 | update | train | func (d *Deployment) update() error {
select {
case event, ok := <-d.events:
if !ok {
return fmt.Errorf("service stream closed unexpectedly: %s", d.stream.Err())
}
if event.Kind == discoverd.EventKindServiceMeta {
d.meta = event.ServiceMeta
}
default:
}
return nil
} | go | {
"resource": ""
} |
q27596 | MarkDone | train | func (d *Deployment) MarkDone(addr string) error {
return attempts.Run(func() error {
if err := d.update(); err != nil {
return err
}
deploymentMeta, err := d.decode(d.meta)
if err != nil {
return err
}
deploymentMeta.States[addr] = DeploymentStateDone
return d.set(d.meta, deploymentMeta)
})
} | go | {
"resource": ""
} |
q27597 | Wait | train | func (d *Deployment) Wait(id string, timeout time.Duration, log log15.Logger) error {
timeoutCh := time.After(timeout)
for {
actual := 0
select {
case event, ok := <-d.events:
if !ok {
return fmt.Errorf("service stream closed unexpectedly: %s", d.stream.Err())
}
if event.Kind == discoverd.EventKind... | go | {
"resource": ""
} |
q27598 | Create | train | func (d *Deployment) Create(id string) error {
return attempts.Run(func() error {
if err := d.set(&discoverd.ServiceMeta{}, NewDeploymentMeta(id)); err == nil {
return nil
}
if err := d.update(); err != nil {
return err
}
return d.set(d.meta, NewDeploymentMeta(id))
})
} | go | {
"resource": ""
} |
q27599 | Attach | train | func (c *Host) Attach(req *host.AttachReq, wait bool) (AttachClient, error) {
rwc, err := c.c.Hijack("POST", "/attach", http.Header{"Upgrade": {"flynn-attach/0"}}, req)
if err != nil {
return nil, err
}
attachState := make([]byte, 1)
if _, err := rwc.Read(attachState); err != nil {
rwc.Close()
return nil, e... | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.