本文整理汇总了Golang中github.com/flynn/flynn/pkg/stream.Stream.Err方法的典型用法代码示例。如果您正苦于以下问题:Golang Stream.Err方法的具体用法?Golang Stream.Err怎么用?Golang Stream.Err使用的例子?那么恭喜您, 这里精选的方法代码示例或许可以为您提供帮助。您也可以进一步了解该方法所在类github.com/flynn/flynn/pkg/stream.Stream
的用法示例。
在下文中一共展示了Stream.Err方法的8个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的Golang代码示例。
示例1: waitForJobEvents
func waitForJobEvents(t *c.C, stream stream.Stream, events chan *ct.JobEvent, expected jobEvents) (lastID int64, jobID string) {
debugf(t, "waiting for job events: %v", expected)
actual := make(jobEvents)
for {
inner:
select {
case event, ok := <-events:
if !ok {
t.Fatalf("job event stream closed: %s", stream.Err())
}
debugf(t, "got job event: %s %s %s", event.Type, event.JobID, event.State)
lastID = event.ID
jobID = event.JobID
if _, ok := actual[event.Type]; !ok {
actual[event.Type] = make(map[string]int)
}
switch event.State {
case "starting", "up", "down":
actual[event.Type][event.State] += 1
case "crashed":
actual[event.Type]["down"] += 1
default:
break inner
}
if jobEventsEqual(expected, actual) {
return
}
case <-time.After(60 * time.Second):
t.Fatal("timed out waiting for job events: ", expected)
}
}
}
示例2: Register
func (d *discoverdWrapper) Register() (bool, error) {
log := logger.New("fn", "discoverd.Register")
log.Info("registering with service discovery")
hb, err := discoverd.AddServiceAndRegister(serviceName, d.addr)
if err != nil {
log.Error("error registering with service discovery", "err", err)
return false, err
}
shutdown.BeforeExit(func() { hb.Close() })
selfAddr := hb.Addr()
log = log.New("self.addr", selfAddr)
service := discoverd.NewService(serviceName)
var leaders chan *discoverd.Instance
var stream stream.Stream
connect := func() (err error) {
log.Info("connecting service leader stream")
leaders = make(chan *discoverd.Instance)
stream, err = service.Leaders(leaders)
if err != nil {
log.Error("error connecting service leader stream", "err", err)
}
return
}
if err := connect(); err != nil {
return false, err
}
go func() {
outer:
for {
for leader := range leaders {
if leader == nil {
// a nil leader indicates there are no instances for
// the service, ignore and wait for an actual leader
log.Warn("received nil leader event")
continue
}
log.Info("received leader event", "leader.addr", leader.Addr)
d.leader <- leader.Addr == selfAddr
}
log.Warn("service leader stream disconnected", "err", stream.Err())
for {
if err := connect(); err == nil {
continue outer
}
time.Sleep(100 * time.Millisecond)
}
}
}()
select {
case isLeader := <-d.leader:
return isLeader, nil
case <-time.After(30 * time.Second):
return false, errors.New("timed out waiting for current service leader")
}
}
示例3: streamHostEvents
func (s *Scheduler) streamHostEvents() error {
log := logger.New("fn", "streamHostEvents")
var events chan *discoverd.Event
var stream stream.Stream
connect := func() (err error) {
log.Info("connecting host event stream")
events = make(chan *discoverd.Event, eventBufferSize)
stream, err = s.StreamHostEvents(events)
if err != nil {
log.Error("error connecting host event stream", "err", err)
}
return
}
if err := connect(); err != nil {
return err
}
current := make(chan struct{})
go func() {
var isCurrent bool
outer:
for {
for event := range events {
switch event.Kind {
case discoverd.EventKindCurrent:
if !isCurrent {
isCurrent = true
close(current)
}
case discoverd.EventKindUp, discoverd.EventKindDown:
// if we are not current, explicitly handle the event
// so that the scheduler is streaming job events from
// all current hosts before starting the main loop.
if !isCurrent {
s.HandleHostEvent(event)
continue
}
s.hostEvents <- event
}
}
log.Warn("host event stream disconnected", "err", stream.Err())
for {
if err := connect(); err == nil {
continue outer
}
time.Sleep(100 * time.Millisecond)
}
}
}()
select {
case <-current:
return nil
case <-time.After(30 * time.Second):
return errors.New("timed out waiting for current host list")
}
}
示例4: waitForJobRestart
func waitForJobRestart(t *c.C, stream stream.Stream, events chan *ct.JobEvent, typ string, timeout time.Duration) string {
debug(t, "waiting for job restart")
for {
select {
case event, ok := <-events:
if !ok {
t.Fatalf("job event stream closed: %s", stream.Err())
}
debug(t, "got job event: ", event.Type, event.JobID, event.State)
if event.Type == typ && event.State == "up" {
return event.JobID
}
case <-time.After(timeout):
t.Fatal("timed out waiting for job restart")
}
}
}
示例5: Register
func (d *discoverdWrapper) Register() bool {
log := d.logger.New("fn", "discoverd.Register")
var hb discoverd.Heartbeater
for {
var err error
log.Info("registering with service discovery")
hb, err = discoverd.AddServiceAndRegister(serviceName, ":"+os.Getenv("PORT"))
if err == nil {
break
}
log.Error("error registering with service discovery", "err", err)
time.Sleep(time.Second)
}
shutdown.BeforeExit(func() { hb.Close() })
selfAddr := hb.Addr()
log = log.New("self.addr", selfAddr)
service := discoverd.NewService(serviceName)
var leaders chan *discoverd.Instance
var stream stream.Stream
connect := func() (err error) {
log.Info("connecting service leader stream")
leaders = make(chan *discoverd.Instance)
stream, err = service.Leaders(leaders)
if err != nil {
log.Error("error connecting service leader stream", "err", err)
}
return
}
go func() {
for {
for {
if err := connect(); err == nil {
break
}
time.Sleep(100 * time.Millisecond)
}
for leader := range leaders {
if leader == nil {
// a nil leader indicates there are no instances for
// the service, ignore and wait for an actual leader
log.Warn("received nil leader event")
continue
}
log.Info("received leader event", "leader.addr", leader.Addr)
d.leader <- leader.Addr == selfAddr
}
log.Warn("service leader stream disconnected", "err", stream.Err())
}
}()
start := time.Now()
tick := time.Tick(30 * time.Second)
for {
select {
case isLeader := <-d.leader:
return isLeader
case <-tick:
log.Warn("still waiting for current service leader", "duration", time.Since(start))
}
}
}
示例6: streamFormationEvents
func (s *Scheduler) streamFormationEvents() error {
log := logger.New("fn", "streamFormationEvents")
var events chan *ct.ExpandedFormation
var stream stream.Stream
var since *time.Time
connect := func() (err error) {
log.Info("connecting formation event stream")
events = make(chan *ct.ExpandedFormation, eventBufferSize)
stream, err = s.StreamFormations(since, events)
if err != nil {
log.Error("error connecting formation event stream", "err", err)
}
return
}
strategy := attempt.Strategy{Delay: 100 * time.Millisecond, Total: time.Minute}
if err := strategy.Run(connect); err != nil {
return err
}
current := make(chan struct{})
go func() {
var isCurrent bool
outer:
for {
for formation := range events {
// an empty formation indicates we now have the
// current list of formations.
if formation.App == nil {
if !isCurrent {
isCurrent = true
close(current)
}
continue
}
since = &formation.UpdatedAt
// if we are not current, explicitly handle the event
// so that the scheduler has the current list of
// formations before starting the main loop.
if !isCurrent {
s.HandleFormationChange(formation)
continue
}
s.formationEvents <- formation
}
log.Warn("formation event stream disconnected", "err", stream.Err())
for {
if err := connect(); err == nil {
continue outer
}
time.Sleep(100 * time.Millisecond)
}
}
}()
select {
case <-current:
return nil
case <-time.After(30 * time.Second):
return errors.New("timed out waiting for current formation list")
}
}
示例7: watchBackends
func (r *Router) watchBackends() {
log := r.logger.New("fn", "router.watchBackends", "router.id", r.ID)
var events chan *router.StreamEvent
var stream stream.Stream
connect := func() (err error) {
log.Info("connecting router event stream")
events = make(chan *router.StreamEvent)
opts := &router.StreamEventsOptions{
EventTypes: []router.EventType{
router.EventTypeBackendUp,
router.EventTypeBackendDrained,
},
}
stream, err = r.client.StreamEvents(opts, events)
if err != nil {
log.Error("error connecting router event stream", "err", err)
}
return
}
// make initial connection
for {
if err := connect(); err == nil {
defer stream.Close()
break
}
select {
case <-r.stop:
return
case <-time.After(100 * time.Millisecond):
}
}
for {
eventLoop:
for {
select {
case event, ok := <-events:
if !ok {
break eventLoop
}
r.events <- &RouterEvent{
RouterID: r.ID,
Type: event.Event,
Backend: event.Backend,
}
case <-r.stop:
return
}
}
log.Warn("router event stream disconnected", "err", stream.Err())
// keep trying to reconnect, unless we are told to stop
retryLoop:
for {
select {
case <-r.stop:
return
default:
}
if err := connect(); err == nil {
break retryLoop
}
time.Sleep(100 * time.Millisecond)
}
}
}
示例8: StreamEventsTo
// StreamEventsTo streams all job events from the host to the given channel in
// a goroutine, returning the current list of active jobs.
func (h *Host) StreamEventsTo(ch chan *host.Event) (map[string]host.ActiveJob, error) {
log := h.logger.New("fn", "StreamEventsTo", "host.id", h.ID)
var events chan *host.Event
var stream stream.Stream
connect := func() (err error) {
log.Info("connecting job event stream")
events = make(chan *host.Event)
stream, err = h.client.StreamEvents("all", events)
if err != nil {
log.Error("error connecting job event stream", "err", err)
}
return
}
if err := connect(); err != nil {
return nil, err
}
log.Info("getting active jobs")
jobs, err := h.client.ListJobs()
if err != nil {
log.Error("error getting active jobs", "err", err)
return nil, err
}
log.Info(fmt.Sprintf("got %d active job(s) for host %s", len(jobs), h.ID))
go func() {
defer stream.Close()
defer close(h.done)
for {
eventLoop:
for {
select {
case event, ok := <-events:
if !ok {
break eventLoop
}
ch <- event
case <-h.stop:
return
}
}
log.Warn("job event stream disconnected", "err", stream.Err())
// keep trying to reconnect, unless we are told to stop
retryLoop:
for {
select {
case <-h.stop:
return
default:
}
if err := connect(); err == nil {
break retryLoop
}
time.Sleep(100 * time.Millisecond)
}
}
}()
return jobs, nil
}