Golang Context.Done方法代码示例

func (s *server) doSearch(ctx context.Context, backend *Backend, q *client.Query) (*api.ReplySearch, error) {
	var cl client.Client
	var search client.Search
	var err error

	select {
	case cl = <-backend.Clients:
	case <-ctx.Done():
		return nil, ErrTimedOut
	}
	defer backend.CheckIn(cl)

	search, err = cl.Query(q)
	if err != nil {
		log.Printf(ctx, "error talking to backend err=%s", err)
		return nil, err
	}

	reply := &api.ReplySearch{Results: make([]*client.Result, 0)}

	for r := range search.Results() {
		reply.Results = append(reply.Results, r)
	}

	reply.Info, err = search.Close()
	if err != nil {
		return nil, err
	}
	return reply, nil
}

// rpcCallTablet wil execute the RPC on the remote server.
func (client *GoRpcTabletManagerClient) rpcCallTablet(ctx context.Context, tablet *topo.TabletInfo, name string, args, reply interface{}) error {
	// create the RPC client, using ctx.Deadline if set, or no timeout.
	var connectTimeout time.Duration
	deadline, ok := ctx.Deadline()
	if ok {
		connectTimeout = deadline.Sub(time.Now())
		if connectTimeout < 0 {
			return fmt.Errorf("Timeout connecting to TabletManager.%v on %v", name, tablet.Alias)
		}
	}
	rpcClient, err := bsonrpc.DialHTTP("tcp", tablet.Addr(), connectTimeout, nil)
	if err != nil {
		return fmt.Errorf("RPC error for %v: %v", tablet.Alias, err.Error())
	}
	defer rpcClient.Close()

	// use the context Done() channel. Will handle context timeout.
	call := rpcClient.Go(ctx, "TabletManager."+name, args, reply, nil)
	select {
	case <-ctx.Done():
		return fmt.Errorf("Timeout waiting for TabletManager.%v to %v", name, tablet.Alias)
	case <-call.Done:
		if call.Error != nil {
			return fmt.Errorf("Remote error for %v: %v", tablet.Alias, call.Error.Error())
		} else {
			return nil
		}
	}
}

func Recv(ctx context.Context, errc chan<- error, sysfd int, tcpconn *net.TCPConn) (reqc chan *Request) {
	reqc = make(chan *Request, 10) // TODO(zog): is 10 a good number?

	go func() {
		defer func() {
			glog.Infof("Recv is stoped")
		}()

		var req *Request
		var err error
		for {
			select {
			case <-ctx.Done():
				glog.Infof("Done for Recv")
				return

			default:
				if req, err = recv(tcpconn); err != nil {
					errc <- fmt.Errorf("in Recv: %s", err)
					return
				}
				reqc <- req
			}
		}
	}()

	return reqc
}

func Send(ctx context.Context, errc chan<- error, sysfd int, tcpconn *net.TCPConn) (rspc chan *Response) {
	rspc = make(chan *Response, 10) // TODO(zog): is 10 a good number?

	go func() {
		defer func() {
			glog.Infof("Send is stoped")
		}()

		for {
			select {
			case <-ctx.Done():
				glog.Infof("Done for Send")
				return

			case rsp := <-rspc:
				if err := send(tcpconn, rsp); err != nil {
					errc <- fmt.Errorf("in Send: %s", err)
					return
				}
			}
		}
	}()

	return rspc
}

func Work(ctx context.Context, errc chan<- error, sysfd int, reqc <-chan *Request, inreqc <-chan *Request, rspc chan<- *Response) {
	go func() {
		defer func() {
			glog.Infof("Work is stoped")
		}()

		for {
			var rsp *Response
			var err error
			select {
			case <-ctx.Done():
				glog.Infof("Done for Work")
				return

			case req := <-reqc:
				if rsp, err = work(req); err != nil {
					errc <- fmt.Errorf("in Work req channel: %s", err)
					return
				}
				rspc <- rsp

			case req := <-inreqc:
				var rsp *Response
				if rsp, err = work(req); err != nil {
					errc <- fmt.Errorf("in Work inner req channel: %s", err)
					return
				}
				rspc <- rsp
			}
		}
	}()
}

// newGateway does all the gateway initialisation once the gateway name is known
func (g *Gateway) newGateway(ctx context.Context, certificateFile, keyFile string) (*Gateway, error) {

	gips, err := lookupGateway(g.gateway)
	if nil != err {
		return nil, err
	}
	ipMap := map[string]int8{}
	for _, ip := range gips {
		ipMap[ip] = 0
	}
	g.gips = ips{ipMap: ipMap}
	g.errors = make(chan *PushNotificationRequestResponse)
	g.senders = []*Sender{}
	// TODO GSE: Enable the possibilty to choose the number of senders
	err = g.newSender(ctx, certificateFile, keyFile)
	if err != nil {
		return nil, err
	}
	go func() {
		for {
			select {
			case <-ctx.Done():
				return
			case pnrr := <-g.errors:
				if g.onError != nil {
					go g.onError(pnrr.Notification, pnrr.Response)
				}
			}
		}
	}()
	return g, nil
}

func transmitter(id string, ws *websocket.Conn, c chan *registrar.T, ctx context.Context, cancel context.CancelFunc) {
	var err error
	var data *registrar.T
	defer ws.Close()
	//defer close(c)
	defer cancel()
	defer registrar.RemoveConnection(id)
Loop:
	for {
		select {
		case data = <-c:
			err = websocket.JSON.Send(ws, *data)
			//websocket.Message.Send(ws, data.Msg)
			if err != nil {
				if !ws.IsClientConn() {
					log.Printf("transmitter closed\n")
				} else {
					log.Printf("transmitter error %v\n", err)
				}
				break Loop
			}
		case <-ctx.Done():
			log.Printf("transmitter closed")
			break Loop
		}
	}
}

// Send sends push notification to the APNs.
func (c *PersistentClient) Send(ctx context.Context, pn *PushNotification) *PushNotificationResponse {

	resp := NewPushNotificationResponse(pn)
	payload, err := pn.ToBytes()
	if err != nil {
		resp.Success = false
		resp.Error = err
		return resp
	}

	_, err = c.Write(payload)
	if err != nil {
		resp.Success = false
		resp.ResponseCommand = LocalResponseCommand
		resp.ResponseStatus = RetryPushNotificationStatus
		resp.Error = err
		return resp
	}
	log.Println("Sending push notification with ID", pn.Identifier)

	// This channel will contain the raw response
	// from Apple in the event of a failure.
	responseChannel := make(chan []byte, 1)
	go func() {
		buffer := make([]byte, 6)
		n, err := c.Read(buffer)
		if n != 6 && err != nil {
			buffer[0] = LocalResponseCommand
			e, ok := err.(net.Error)
			switch {
			case err == io.EOF: // Socket has been closed
				buffer[1] = RetryPushNotificationStatus
			case ok && e.Timeout(): // There is an error and it is a timeout
				buffer[1] = NoErrorsStatus
			default:
				buffer[1] = UnknownErrorStatus
			}
		}
		responseChannel <- buffer
	}()

	select {
	case <-ctx.Done():
		<-responseChannel // Wait for the read to end.
		resp.Success = false
		resp.ResponseCommand = LocalResponseCommand
		resp.ResponseStatus = CanceledPushNotificationStatus
		resp.Error = ctx.Err()
	case r := <-responseChannel:
		resp.FromRawAppleResponse(r)
	}
	return resp
}

// WithContext constructs and returns a Process that respects
// given context. It is the equivalent of:
//
//   func ProcessWithContext(ctx context.Context) goprocess.Process {
//     p := goprocess.WithParent(goprocess.Background())
//     go func() {
//       <-ctx.Done()
//       p.Close()
//     }()
//     return p
//   }
//
func WithContext(ctx context.Context) goprocess.Process {
	if ctx == nil {
		panic("nil Context")
	}

	p := goprocess.WithParent(goprocess.Background())
	go func() {
		<-ctx.Done()
		p.Close()
	}()
	return p
}

// httpDo issues the HTTP request and calls f with the response. If ctx.Done is
// closed while the request or f is running, httpDo cancels the request, waits
// for f to exit, and returns ctx.Err. Otherwise, httpDo returns f's error.
func httpDo(ctx context.Context, req *http.Request, f func(*http.Response, error) error) error {
	// Run the HTTP request in a goroutine and pass the response to f.
	tr := &http.Transport{}
	client := &http.Client{Transport: tr}
	c := make(chan error, 1)
	go func() { c <- f(client.Do(req)) }()
	select {
	case <-ctx.Done():
		tr.CancelRequest(req)
		<-c // Wait for f to return.
		return ctx.Err()
	case err := <-c:
		return err
	}
}

func main() {

	var server string

	var (
		ctx    context.Context
		cancel context.CancelFunc
	)

	ctx, cancel = context.WithCancel(context.Background())

	runtime.GOMAXPROCS(1)

	server = os.Args[1]
	id := os.Args[2]

	LogConditional(printLog, fmt.Printf, "Client Id %s\n", id)
	//fmt.Printf("Client Id %s\n", id)

	var headers http.Header = make(http.Header)
	headers.Add("X-Client-ID", id)

	var srvurl = "ws://173.39.210.210:8080/echo/"

	origin = fmt.Sprintf("http://%s/", server)
	srvurl = fmt.Sprintf("ws://%s:8080/echo/?id=%s", server, id)

	u, err := url.Parse(srvurl)
	o, err := url.Parse(origin)
	ws, err := websocket.DialConfig(&websocket.Config{Location: u, Header: headers, Origin: o, Version: 13})

	if err != nil {
		log.Fatal(err)
	}

	c := make(chan []byte)

	go collectdTcp(cancel, c)
	go collectSyslog(c)
	go writer(ws, id, c)
	//go reader(ws, id)

	select {
	case <-ctx.Done():
	}

}

func main() {

	var server string

	runtime.GOMAXPROCS(1)
	R = *new(responses)
	R.waiting = make(map[int64]response)
	rand.Seed(time.Now().UnixNano())
	var (
		ctx context.Context
	)

	ctx, _ = context.WithCancel(context.Background())

	server = os.Args[1]
	id := os.Args[2]
	printLog = (os.Args[3] == "1")
	fmt.Sscanf(os.Args[4], "%d", &loopCount)

	LogConditional(printLog, fmt.Printf, "Client Id %s\n", id)
	//fmt.Printf("Client Id %s\n", id)

	var headers http.Header = make(http.Header)
	headers.Add("X-Client-ID", id)

	var srvurl = "ws://173.39.210.210:8080/echo/"

	origin = fmt.Sprintf("http://%s/", server)
	srvurl = fmt.Sprintf("ws://%s:8080/echo/?id=%s", server, id)

	u, err := url.Parse(srvurl)
	o, err := url.Parse(origin)
	ws, err := websocket.DialConfig(&websocket.Config{Location: u, Header: headers, Origin: o, Version: 13})

	if err != nil {
		log.Fatal(err)
	}

	go writer(ws, id)
	go reader(ws, id)

	select {
	case <-ctx.Done():
	}

}

// Listen will handle connections on given port.
// Listen will return upon cancellation of context.
func Listen(ctx context.Context, port string, handle Handler) error {
	ln, err := net.Listen("tcp", port)
	if err != nil {
		return err
	}

	// Stop accepting connections upon cancellation.
	go func() {
		<-ctx.Done()
		ln.Close()
	}()

	for {
		conn, err := ln.Accept()
		if err != nil {
			select {
			case <-ctx.Done():
				// No error because the server has been intentionally cancelled.
				return nil
			default:
				log.Error(err)
				continue // TODO should this continue?
			}
		}

		// Create a connection specific logger.
		l := log.WithFields(log.Fields{
			"remote": conn.RemoteAddr(),
		})

		ctx := tcplog.NewContext(ctx, l)

		go func() {
			l.Debugf("handling connection")
			err := handle(ctx, conn)
			if err != nil {
				l.Error(err)
			}
			// Close the connection once the handler has returned.
			conn.Close()
		}()
	}
}

func Update(ctx context.Context, errc chan<- error, sysfd int, rspc chan<- *Response) {
	go func() {
		defer func() {
			glog.Infof("Update is stoped")
		}()

		for {
			select {
			case <-ctx.Done():
				glog.Infof("Done for Update")
				return

			default:
				if err := update(sysfd, rspc); err != nil {
					errc <- fmt.Errorf("in Update: %s", err)
					return
				}
			}
		}
	}()
}

// redial continually connects to the URL, exiting the program when no longer possible
func redial(ctx context.Context, url string) chan chan session {
	sessions := make(chan chan session)

	go func() {
		sess := make(chan session)
		defer close(sessions)

		for {
			select {
			case sessions <- sess:
			case <-ctx.Done():
				log.Println("shutting down session factory")
				return
			}

			conn, err := amqp.Dial(url)
			if err != nil {
				log.Fatalf("cannot (re)dial: %v: %q", err, url)
			}

			ch, err := conn.Channel()
			if err != nil {
				log.Fatalf("cannot create channel: %v", err)
			}

			if err := ch.ExchangeDeclare(exchange, "fanout", false, true, false, false, nil); err != nil {
				log.Fatalf("cannot declare fanout exchange: %v", err)
			}

			select {
			case sess <- session{conn, ch}:
			case <-ctx.Done():
				log.Println("shutting down new session")
				return
			}
		}
	}()

	return sessions
}