Golang Conn.Close方法代碼示例

func handleWebSocket(conn *websocket.Conn) {
	respStatus := http.StatusOK
	defer func() {
		conn.Close()
		logRequest(HTTPS_WEBSOCKET, respStatus, conn.Request().Host, conn.Request())
	}()
	request := make([]byte, 1024)
	for {
		n, err := conn.Read(request)
		if err != nil {
			if debugMode {
				log.Error("Error reading on WebSocket: %s", err)
			}
			break
		}
		response, status := getLiveItems(string(request[:n]))
		if status != http.StatusOK {
			respStatus = status
			break
		}
		if len(response) != 0 {
			if _, err = conn.Write(response); err != nil {
				break
			}
		}
	}
}

func clientHandler(ws *websocket.Conn) {
	defer func() {
		subscriptionChan <- subscription{ws, false}
		ws.Close()
	}()

	subscriptionChan <- subscription{ws, true}

	for {
		buf := make([]byte, 128)
		n, err := ws.Read(buf)
		if err != nil {
			log.Print("Reading Buffer: ", err)
			break
		}

		var m message
		err = json.Unmarshal(buf[0:n], &m)
		if err != nil {
			log.Print("Parsing JSON: ", buf, m, err)
			break
		}

		messageChan <- message{m.Text, m.Id, m.User, m.Command}
	}
}

func LobbyServer(ws *websocket.Conn) {
	reader := bufio.NewReader(ws)
	var username string
	var player *Player
	connected := false
	sendPlayers(ws)
	inGame := false

	for {
		br, er := reader.ReadString('\n')
		if er == os.EOF {
			break
		}

		msg := strings.Split(br, " ")

		switch msg[0] {
		case "connect":
			username = strings.TrimSpace(msg[1])

			if _, ok := users[username]; !ok && !connected {
				player = &Player{Name: username, Socket: ws}
				sendPlayer(player)
				users[username] = player
				fmt.Printf("Got connection from %s\n", username)
				connected = true
			} else {
				fmt.Fprint(ws, "error Username Exists")
				ws.Close()
				return
			}
		case "create":
			if inGame {
				fmt.Fprint(ws, "error Already in a game")
				continue
			}
			fmt.Printf("Create %s\n", username)
			sendPlayer(player)
			inGame = true
			continue

		case "start":
			fmt.Printf("Game %s\n", br)
			for _, info := range users {
				fmt.Fprintf(info.Socket, "Game %s", "start")
			}

		case "point":
			user := strings.TrimSpace(msg[1])
			point, _ := strconv.Atoi(strings.TrimSpace(msg[2]))
			player = &Player{Name: user, Point: point, Socket: ws}
			sendPlayer(player)
			users[username] = player
			continue

		default:
			fmt.Printf("Unknown message: %s\n", br)
		}
	}
}

/*
 * Get messages from client
 */
func clientHandler(ws *websocket.Conn) {
	defer func() {
		log.Println("Client handler closed.")
		ws.Close()
	}()

	buf := make([]byte, 256)
	stopCh := make(chan bool)
	var input ProcessInput
	for {
		n, err := ws.Read(buf)
		if err != nil {
			break
		}

		// get data
		err = json.Unmarshal(buf[0:n], &input)
		if err != nil {
			stopCh <- true
			break
		}

		workChan <- Work{ws, &input, stopCh}
	}
}

func throwFatal(ws *websocket.Conn, reason string) {
	msg := message{
		Channel: "",
		Data: map[string]string{
			"response": "error",
			"reason":   reason,
		},
		Auth: Auth{},
		Mode: "error",
	}
	websocket.JSON.Send(ws, msg)
	unsubscribe(ws)
	ws.Close()
}

func Handle(ws *websocket.Conn) {
	fmt.Println("New Connection.")
	encoder := json.NewEncoder(ws)
	i := 0
	for _, line := range lines {
		i++
		if i > 47 {
			time.Sleep(time.Duration((rand.Intn(2000) + 700) * int(time.Millisecond)))
		}
		data := struct{ Server, Line string }{"irc.foonetic.net", line}
		encoder.Encode(data)
	}
	fmt.Println("Conn closed.")
	ws.Close()
}

func (m *model) subscribe(s *websocket.Conn) {
	data, err := json.MarshalIndent(newConnectMessage(m.Changes, m.Kittens, m.VersionIdentifier), "", "  ")
	if err != nil {
		s.Close()
		return
	}

	_, err = s.Write(data)
	if err != nil {
		s.Close()
		return
	}

	m.Conns[s] = 1
}

func clientHandler(ws *websocket.Conn) {
	defer func() {
		subscriptionChan <- subscription{ws, false}
		ws.Close()
	}()

	subscriptionChan <- subscription{ws, true}

	buf := make([]byte, 256)
	for {
		n, err := ws.Read(buf)
		if err != nil {
			break
		}
		messageChan <- buf[0:n]
	}
}

func SocketServer(ws *websocket.Conn) {
	c := make(chan []byte, 100)
	e := ws_channels.PushBack(c)
	fmt.Printf("New connection:    %v total\n", ws_channels.Len())
	var data []byte
	for {
		select {
		case data = <-c:
		case <-time.After(5e9): // make sure we're still connected
			data = []byte("")
		}

		if _, err := ws.Write(data); err != nil {
			// fmt.Println("Closing")
			ws.Close()
			break
		}
	}
	ws_channels.Remove(e)
	fmt.Printf("Closed connection: %v total\n", ws_channels.Len())
}

func wsHandler(ws *websocket.Conn) {
	defer func() {
		unsubscribe(ws)
		ws.Close()
	}()

	subscribe(ws)

	for { // loop forEVER
		var data message
		err := websocket.JSON.Receive(ws, &data)
		if err != nil {
			log.Print("wsHandler > websocket.JSON.Receive: " + err.Error())
			break
		}
		if data.Channel != "" {
			setChannel(ws, data.Channel)
		} else {
			throwFatal(ws, "Must specify a Channel name")
		}
		if data.Auth.User != "" {
			log.Print(data.Auth)
			auth, err := checkAPIAuth(data.Auth.User, data.Auth.Secret)
			if err != nil {
				throwFatal(ws, "Server error. Please try again later.")
			} else {
				if auth {
					if device := strings.Split(data.Channel, "/"); device[0] != data.Auth.User {
						throwFatal(ws, "Unauthorised use of device.")
					} else {
						authorise(ws, data.Auth.User, data.Auth.Secret)
						messageChan <- data
					}
				} else {
					throwFatal(ws, "Auth parameters invalid.")
				}
			}
		}
	}
}

func doEventStream(ws *websocket.Conn) {
	ID := chat.UUID()
	defer func() {
		subscriptionChan <- &Subscription{ws, chat.REMOVE_CONNECTION, &User{ID, nil, ""}}
		ws.Close()
	}()

	subscriptionChan <- &Subscription{ws, chat.ADD_CONNECTION, &User{ID, nil, ""}}
	newStartMessage, _ := json.Marshal(
		MessageData{
			"start",
			map[string]interface{}{
				"ID": ID,
			}})

	ws.Write(newStartMessage)

	for {
		buf := make([]byte, 1024)

		n, err := ws.Read(buf)
		if err != nil {
			log.Println("Error reading from websocket connection: ", err.Error())
			break
		}

		newMessageData := new(MessageData)
		err = json.Unmarshal(buf[0:n], newMessageData)

		if err != nil {
			log.Println("Error unmarshaling message: ", string(buf[0:n]), " : ", err.Error())
		}

		messageChan <- message{
			ws,
			*newMessageData,
		}
	}
}

func liveReload16ConnectionHandler(ws *websocket.Conn) {
	defer func() {
		subscriptionChannel <- subscriptionMessage{ws, false, ""}
		fmt.Printf("Browser disconnected")
		ws.Close()
	}()

	websocket.Message.Send(ws, fmt.Sprintf("!!ver:%s", API_VERSION))
	fmt.Printf("Browser Connected")

	// on connection it's the client url
	var onConnectionMessage string
	websocket.Message.Receive(ws, &onConnectionMessage)
	subscriptionChannel <- subscriptionMessage{ws, true, onConnectionMessage}
	fmt.Printf("Browser URL: %s", onConnectionMessage)

	// websocket messages from the clients get pushed though the eventhub
	for {
		var msg string
		websocket.Message.Receive(ws, &msg)
		messageChannel <- msg
	}
}

func broadcastHandler(ws *websocket.Conn) {
	defer func() {
		subscriptionChan <- subscription{ws, false}
		ws.Close()
		fmt.Printf("Closed \n")
	}()

	fmt.Printf("Adding to subscription \n")

	subscriptionChan <- subscription{ws, true}
	fmt.Printf("Added to subscription \n")

	buf := make([]byte, 256)
	for {
		n, err := ws.Read(buf)
		fmt.Printf("Reding message %v \n", n)

		if err != nil {
			break
		}
		messageChan <- buf[0:n]
	}
}

func doEventStream(ws *websocket.Conn) {
	defer func() {
		subscriptionChan <- subscription{ws, false}
		ws.Close()
	}()

	subscriptionChan <- subscription{ws, true}

	for {
		buf := make([]byte, 512)

		n, err := ws.Read(buf)
		if err != nil {
			log.Println("Error reading from websocket connection")
			break
		}

		messageChan <- message{
			ws,
			buf[0:n],
		}
	}
}

func TestAllTheThings(t *testing.T) {
	var ws *websocket.Conn
	var req net.Conn
	var wss [5]*websocket.Conn

	ws = websocketDial(t)
	testWebsocketConnect(t, ws)
	testWebsocketBadRequests(t, ws)
	testWebsocketAuthenticationWithoutToken(t, ws)
	testWebsocketAuthenticationWithInvalidTokenFormat(t, ws)
	testWebsocketAuthenticationWithInvalidToken(t, ws)
	testWebsocketAuthenticationWithValidToken(t, ws)
	testWebsocketSubscribeWithoutChannelName(t, ws)
	testWebsocketSubscribeWithEmptyChannelName(t, ws)
	testWebsocketSubscribeWithInvalidChannelName(t, ws)
	testWebsocketSubscribeToNotExistingChannel(t, ws)
	testWebsocketUnsubscribeWithoutChannelName(t, ws)
	testWebsocketUnsubscribeWithEmptyChannelName(t, ws)
	testWebsocketUnsubscribeWithInvalidChannelName(t, ws)
	testWebsocketUnsubscribeNotSubscribedChannel(t, ws)
	ws.Close()

	ws = websocketDial(t)
	testWebsocketConnect(t, ws)
	testWebsocketSubscribeToPublicChannel(t, ws)
	testWebsocketUnsubscribeSubscribedChannel(t, ws)
	testWebsocketSubscribeToPrivateChannelWithoutAuthentication(t, ws)
	testWebsocketSubscribeToPresenceChannelWithoutAuthentication(t, ws)
	testWebsocketAuthenticationWithValidToken(t, ws)
	testWebsocketSubscribeToPrivateChannelWithAuthentication(t, ws)
	testWebsocketSubscribeToPresenceChannelWithAuthentication(t, ws)
	ws.Close()

	for i := range wss {
		wss[i] = websocketDial(t)
		testWebsocketConnect(t, wss[i])
		testWebsocketAuthenticationWithValidToken(t, wss[i])
	}
	testWebsocketPresenceChannelSubscribeBehaviour(t, wss[:])
	testWebsocketPresenceChannelUnsubscribeBehaviour(t, wss[:])
	for i := range wss {
		wss[i].Close()
		wss[i] = nil
	}

	ws = websocketDial(t)
	testWebsocketConnect(t, ws)
	testWebsocketBroadcastWithoutChannelSpecified(t, ws)
	testWebsocketBroadcastWithEmptyChannelSpecified(t, ws)
	testWebsocketBroadcastWithoutEventSpecified(t, ws)
	testWebsocketBroadcastToNotSubscribedChannel(t, ws)
	testWebsocketBroadcastToNotExistingChannel(t, ws)
	ws.Close()

	for i := range wss {
		wss[i] = websocketDial(t)
		testWebsocketConnect(t, wss[i])
		testWebsocketSubscribeToPublicChannel(t, wss[i])
	}
	testWebsocketBroadcast(t, wss[:])
	testBackendBroadcast(t, req, wss[:])
	for i := range wss {
		wss[i].Close()
		wss[i] = nil
	}

	testBackendBadRequest(t, req)
	testBackendBadIdentity(t, req)
	testBackendOpenChannelWithoutName(t, req)
	testBackendOpenChannelWithInvalidName(t, req)
	testBackendOpenExistingChannel(t, req)
	testBackendOpenNewChannel(t, req)
	testBackendCloseChannelWithoutName(t, req)
	testBackendCloseChannelWithInvalidName(t, req)
	testBackendCloseNotExistingChannel(t, req)
	testBackendRequestSingleAccessTokenWithoutPermission(t, req)
	testBackendRequestSingleAccessTokenWithInvalidPermission(t, req)
	testBackendRequestSingleAccessTokenWithValidPermission(t, req)
	testBackendBroadcastWithEmptyChannelName(t, req)
	testBackendBroadcastWithEmptyEventName(t, req)
	testBackendBroadcastToNotExistingChannel(t, req)
	testBackendBroadcastWithInvalidData(t, req)
}