func TestConnect(t *testing.T) {
	ws_, err := websocket.Dial("ws://localhost:9771/echo", "ws", "http://localhost/")
	ws = ws_
	if err != nil {
		t.Error(err)
	}
}
func websocketDial(t *testing.T) *websocket.Conn {
	ws, err := websocket.Dial("ws://127.0.0.1:9080/test", "ws", "http://127.0.0.1/")
	if err != nil {
		fmt.Printf("%v\n", err)
		os.Exit(1)
	}
	return ws
}
Beispiel #3
0
func pub() {
	ws, err := websocket.Dial("ws://127.0.0.1:8080/broadcast", "", "")
	if err != nil {
		panic(err)
	}
	println("About to write")
	if _, err := ws.Write([]byte(message)); err != nil {
		panic(err)
	}
}
Beispiel #4
0
func (wc *WebsocketClient) Dial(rawurl string, origin string) (err os.Error) {
	var messages []Message
	var nr int

	if wc.connected {
		return ErrConnected
	}

	if wc.ws, err = websocket.Dial(rawurl, "", origin); err != nil {
		return
	}

	// read handshake
	buf := make([]byte, 2048)
	if nr, err = wc.ws.Read(buf); err != nil {
		wc.ws.Close()
		return os.NewError("Dial: " + err.String())
	}
	wc.decBuf.Write(buf[0:nr])

	if messages, err = wc.dec.Decode(); err != nil {
		wc.ws.Close()
		return os.NewError("Dial: " + err.String())
	}

	if len(messages) != 1 {
		wc.ws.Close()
		return os.NewError("Dial: expected exactly 1 message, but got " + strconv.Itoa(len(messages)))
	}

	// TODO: Fix me: The original Socket.IO codec does not have a special encoding for handshake
	// so we should just assume that the first message is the handshake.
	// The old codec should be gone pretty soon (waiting for 0.7 release) so this might suffice
	// until then.
	if _, ok := wc.codec.(SIOCodec); !ok {
		if messages[0].Type() != MessageHandshake {
			wc.ws.Close()
			return os.NewError("Dial: expected handshake, but got " + messages[0].Data())
		}
	}

	wc.sessionid = SessionID(messages[0].Data())
	if wc.sessionid == "" {
		wc.ws.Close()
		return os.NewError("Dial: received empty sessionid")
	}

	wc.connected = true

	go wc.reader()
	return
}
func main() {
	ws, err := websocket.Dial("ws://localhost/ws", "", "http://localhost/")
	if err != nil {
		panic("Dial: " + err.String())
	}
	if _, err := ws.Write([]byte("hello, world!\n")); err != nil {
		panic("Write: " + err.String())
	}
	var msg = make([]byte, 512)
	var n int
	if n, err = ws.Read(msg); err != nil {
	}
	fmt.Println(msg[:n])
}
func TestEvents(t *testing.T) {
	event := DataEvent{Event: "my-custom-event", Channel: "wrong", Data: map[string]string{"foo": "bar"}}
	sendAndCheck(t, event)
	var response ErrorEvent
	err := websocket.JSON.Receive(ws, &response)
	if err != nil {
		t.Error(err)
	}
	if response.Error != "invalid_channel" {
		t.Errorf("Expected `invalid_channel` error, `%s` given", response.Error)
	}
	event.Channel = "test"
	ws2, err := websocket.Dial("ws://localhost:9771/echo", "ws", "http://localhost/")
	if err != nil {
		t.Error(err)
	}
	subscr := ChanneledEvent{Event: "subscribe", Channel: "test"}
	err = websocket.JSON.Send(ws2, subscr)
	if err != nil {
		t.Error(err)
	}
	var response2 NamedEvent
	err = websocket.JSON.Receive(ws2, &response2)
	if response2.Event != "ok" {
		t.Errorf("Expected `ok` event, `%s` given", response2.Event)
	}
	sendAndCheck(t, event)
	checkOkResponse(t)
	var recvEvent DataEvent
	err = websocket.JSON.Receive(ws2, &recvEvent)
	if err != nil {
		t.Error(err)
	}
	if recvEvent.Event != "my-custom-event" || recvEvent.Data["foo"] != "bar" {
		t.Errorf("Received event differs from original one (%s) != (%s)", recvEvent, event)
	}
	err = websocket.JSON.Send(ws2, event)
	if err != nil {
		t.Error(err)
	}
	err = websocket.JSON.Receive(ws2, &response)
	if err != nil {
		t.Error(err)
	}
	if response.Error != "access_denied" {
		t.Errorf("Expected `access_denied` error, `%s` given", response.Error)
	}
}
Beispiel #7
0
// This example demonstrates a trivial client.
func ExampleDial() {
	origin := "http://localhost/"
	url := "ws://localhost:12345/ws"
	ws, err := websocket.Dial(url, "", origin)
	if err != nil {
		log.Fatal(err)
	}
	if _, err := ws.Write([]byte("hello, world!\n")); err != nil {
		log.Fatal(err)
	}
	var msg = make([]byte, 512)
	var n int
	if n, err = ws.Read(msg); err != nil {
		log.Fatal(err)
	}
	fmt.Printf("Received: %s.\n", msg[:n])
}
func setupClient(clientID int) (*websocket.Conn, error) {
	var ws *websocket.Conn
	var err error
	url := fmt.Sprintf("ws://127.0.0.1:8080/redwood/1/%d", clientID)
	for timeout := 1; ; timeout *= 2 {
		ws, err = websocket.Dial(url, "", "http://127.0.0.1")
		if err == nil {
			return ws, nil
		}
		if timeout <= 20 {
			log.Printf("Trying to connect to websocket failed, sleeping %ds", timeout)
			time.Sleep(time.Duration(timeout) * time.Second)
		} else {
			return nil, err
		}
	}
}
Beispiel #9
0
func (wc *WebsocketClient) Dial(rawurl string, origin string) (err os.Error) {
	var messages []Message
	var nr int

	if wc.connected {
		return ErrConnected
	}

	if wc.ws, err = websocket.Dial(rawurl, "", origin); err != nil {
		return
	}

	// read handshake
	buf := make([]byte, 2048)
	if nr, err = wc.ws.Read(buf); err != nil {
		wc.ws.Close()
		return os.NewError("Dial: " + err.String())
	}
	wc.decBuf.Write(buf[0:nr])

	if messages, err = wc.dec.Decode(); err != nil {
		wc.ws.Close()
		return os.NewError("Dial: " + err.String())
	}

	if len(messages) != 1 {
		wc.ws.Close()
		return os.NewError("Dial: expected exactly 1 message, but got " + strconv.Itoa(len(messages)))
	}

	if messages[0].Type() != MessageHandshake {
		wc.ws.Close()
		return os.NewError("Dial: expected handshake, but got " + messages[0].Data())
	}

	wc.sessionid = SessionID(messages[0].Data())
	if wc.sessionid == "" {
		wc.ws.Close()
		return os.NewError("Dial: received empty sessionid")
	}

	wc.connected = true

	go wc.reader()
	return
}
Beispiel #10
0
func main() {
	flag.Parse()

	if len(*host) == 0 {
		fmt.Print("Error: Needs -host parameter.\n")
		os.Exit(1)
	}

	ws, err := websocket.Dial(*host, "", *origin)

	if err != nil {
		fmt.Printf("Error: %s\n", err.String())
		os.Exit(1)
	}

	rw := bufio.NewReadWriter(bufio.NewReader(ws), bufio.NewWriter(ws))
	stdin := bufio.NewReader(os.Stdin)

	go func() {
		for {
			s, error := rw.ReadString('\n')
			s = Strip(s)

			if error != nil {
				fmt.Printf("Error: %s\n", error.String())
				os.Exit(1)
			}

			if len(s) == 0 {
				continue
			}

			fmt.Printf("%s\n", s)
		}
	}()

	for {
		input, _ := stdin.ReadString('\n')
		rw.WriteString(input)
		rw.Flush()
	}
}
Beispiel #11
0
func do_test(w *WSBench, msg []byte) {
	for i := 0; i < w.Connections; i++ {
		start := time.Nanoseconds()
		var path string
		if w.Type == "broadcast" {
			path = w.Type
		} else {
			path = "echo"
		}
		ws, err := websocket.Dial("ws://0.0.0.0:5555/"+path, "", "http://0.0.0.0/")
		if err != nil {
			panic("Dial failed: " + err.String())
		}

		if _, err := ws.Write([]byte(msg)); err != nil {
			panic("Write failed: " + err.String())
		}

		if i%1000 == 0 {
			fmt.Println(i)
		}
		// fmt.Println(bytes.Equal(response, response))

		var response = make([]byte, 512)
		// fmt.Println(bytes.Equal(response, response))
		n, err := ws.Read(response)

		if err != nil {
			panic("Read failed: " + err.String())
		}
		if !bytes.Equal(msg, response[0:n]) {
			panic("Message not the same: " + err.String())
		}
		ws.Close()
		delta := time.Nanoseconds() - start
		// Adding Dummy result for now.
		w.Ch <- Result{time: delta}
	}
	close(w.Ch)
}
Beispiel #12
0
func main() {
	c := make(chan int)
	address := ":" + getenv("PORT", "8080")

	fmt.Printf("Address: %s\n", address)

	go func() {
		http.Handle("/echo", websocket.Handler(EchoServer))
		error := http.ListenAndServe(address, nil)
		if error != nil {
			panic("ListenAndServe: " + error.String())
		}
		c <- 0
	}()

	go func() {
		url := "ws://localhost" + address + "/echo"
		ws, error := websocket.Dial(url, "", "http://localhost/")
		if error != nil {
			panic("Dial:" + error.String())
		}

		if _, error := ws.Write([]byte("Hello world")); error != nil {
			panic("Write: " + error.String())
		}

		var msg = make([]byte, 16384)
		n, error := ws.Read(msg)
		if error != nil {
			panic("Read: " + error.String())
		}

		fmt.Printf("%s\n", msg[0:n])
	}()

	/* Rough equivalent to 'thread.join' waiting for the server to terminate, if
	ever */
	<-c
}
Beispiel #13
0
func main() {
	println(1)
	ws, err := websocket.Dial("ws://localhost:8080/", "", "http://localhost:8080/")
	if err != nil {
		panic("Dial: " + err.String())
	}
	println(2)
	if _, err := ws.Write([]byte("hello, world!\n")); err != nil {
		panic("Write: " + err.String())
	}
	var msg = make([]byte, 512)
	println(3)
	if output, err := ws.Read(msg); err != nil {
		panic("Read: " + err.String())
	} else {
		println(4)
		fmt.Printf("msg: %s\n", msg)
		fmt.Printf("output: %v\n", output)
	}
	println(5)
	// use msg[0:n]
}
Beispiel #14
0
func TestEcho(t *testing.T) {
	once.Do(startServer)
	msg := []byte("hello, world!")
	ws, err := websocket.Dial("ws://0.0.0.0:5555/echo", "", "http://0.0.0.0/")
	if err != nil {
		t.Errorf("WebSocket handshake: %v", err)
	}
	if _, err := ws.Write([]byte(msg)); err != nil {
		t.Errorf("Write: error %v", err)
	}
	var response = make([]byte, 512)
	fmt.Println(bytes.Equal(response, response))
	n, err := ws.Read(response)

	if err != nil {
		t.Errorf("Read: error %v", err)
	}

	if !bytes.Equal(msg, response[0:n]) {
		t.Errorf("Echo: expected %q got %q", msg, response)
	}
	ws.Close()
}
Beispiel #15
0
func main() {
	count := 3
	for i := 0; i < count; i++ {
		ws1, err := websocket.Dial("ws://127.0.0.1:8080/broadcast", "", "")
		if err != nil {
			panic(err)
		}
		go sub(ws1)
	}

	pub()
	l := list.New()
	for {
		res := <-ch

		l.PushBack(1)
		fmt.Println("Received: %v,  %+v", l.Len(), res)

		if l.Len() >= count {
			fmt.Println("Got all: %v,  %+v", l.Len(), res)
			return
		}
	}
}
func wsdial(port int) (*websocket.Conn, error) {
	url := fmt.Sprintf("ws://127.0.0.1:%d/test", port)
	return websocket.Dial(url, "ws", "http://127.0.0.1/")
}