func (c *Client) Stream(path string, headers map[string]string, in io.Reader, out io.WriteCloser) error {
origin := fmt.Sprintf("https://%s", c.Host)
endpoint := fmt.Sprintf("wss://%s%s", c.Host, path)
config, err := websocket.NewConfig(endpoint, origin)
if err != nil {
return err
}
config.TlsConfig = &tls.Config{
InsecureSkipVerify: true,
}
config.Header.Set("Version", c.Version)
userpass := fmt.Sprintf("convox:%s", c.Password)
userpass_encoded := base64.StdEncoding.EncodeToString([]byte(userpass))
config.Header.Add("Authorization", fmt.Sprintf("Basic %s", userpass_encoded))
for k, v := range headers {
config.Header.Add(k, v)
}
config.TlsConfig = &tls.Config{
InsecureSkipVerify: true,
}
var ws *websocket.Conn
if proxy := os.Getenv("HTTPS_PROXY"); proxy != "" {
ws, err = c.proxyWebsocket(config, proxy)
} else {
ws, err = websocket.DialConfig(config)
}
if err != nil {
return err
}
defer ws.Close()
var wg sync.WaitGroup
if in != nil {
go io.Copy(ws, in)
}
if out != nil {
wg.Add(1)
go copyAsync(out, ws, &wg)
}
wg.Wait()
out.Close()
return nil
}
func (s *S) TestAppShellUnauthorizedError(c *check.C) {
a := app.App{
Name: "someapp",
Platform: "zend",
TeamOwner: s.team.Name,
}
err := app.CreateApp(&a, s.user)
c.Assert(err, check.IsNil)
err = s.provisioner.AddUnits(&a, 1, "web", nil)
c.Assert(err, check.IsNil)
m := RunServer(true)
server := httptest.NewServer(m)
defer server.Close()
testServerURL, err := url.Parse(server.URL)
c.Assert(err, check.IsNil)
url := fmt.Sprintf("ws://%s/apps/%s/shell?width=140&height=38&term=xterm", testServerURL.Host, a.Name)
config, err := websocket.NewConfig(url, "ws://localhost/")
c.Assert(err, check.IsNil)
wsConn, err := websocket.DialConfig(config)
c.Assert(err, check.IsNil)
defer wsConn.Close()
_, err = wsConn.Write([]byte("echo test"))
c.Assert(err, check.IsNil)
var result string
err = tsurutest.WaitCondition(5*time.Second, func() bool {
part, readErr := ioutil.ReadAll(wsConn)
if readErr != nil {
return false
}
result += string(part)
return result == "Error: no token provided or session expired, please login again\n"
})
c.Assert(err, check.IsNil)
}
func (s *S) TestAppShellGenericError(c *check.C) {
m := RunServer(true)
server := httptest.NewServer(m)
defer server.Close()
testServerURL, err := url.Parse(server.URL)
c.Assert(err, check.IsNil)
url := fmt.Sprintf("ws://%s/apps/someapp/shell?width=140&height=38&term=xterm", testServerURL.Host)
config, err := websocket.NewConfig(url, "ws://localhost/")
c.Assert(err, check.IsNil)
config.Header.Set("Authorization", "bearer "+s.token.GetValue())
wsConn, err := websocket.DialConfig(config)
c.Assert(err, check.IsNil)
defer wsConn.Close()
_, err = wsConn.Write([]byte("echo test"))
c.Assert(err, check.IsNil)
var result string
err = tsurutest.WaitCondition(5*time.Second, func() bool {
part, readErr := ioutil.ReadAll(wsConn)
if readErr != nil {
c.Log(readErr)
return false
}
result += string(part)
return result == "Error: App someapp not found.\n"
})
c.Assert(err, check.IsNil)
}
func (s *authHttpSuite) dialWebsocketFromURL(c *gc.C, server string, header http.Header) *websocket.Conn {
config := s.makeWebsocketConfigFromURL(c, server, header)
c.Logf("dialing %v", server)
conn, err := websocket.DialConfig(config)
c.Assert(err, jc.ErrorIsNil)
return conn
}
func main() {
wsConfig, _ := websocket.NewConfig("wss://www.example2.com/echo", "http://localhost/")
wsConfig.TlsConfig = &tls.Config{
InsecureSkipVerify: true,
ServerName: "www.example2.com",
}
ws, err := websocket.DialConfig(wsConfig)
if err != nil {
log.Fatal(err)
}
message := []byte("hello, world!")
_, err = ws.Write(message)
if err != nil {
log.Fatal(err)
}
fmt.Printf("Send: %s\n", message)
var msg = make([]byte, len(message))
_, err = ws.Read(msg)
if err != nil {
log.Fatal(err)
}
fmt.Printf("Receive: %s\n", msg)
}
func readWebSocket(r *Reader, t *testing.T, fn func(*websocket.Conn), protocols ...string) ([]byte, error) {
errCh := make(chan error, 1)
s, addr := newServer(http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
errCh <- r.Copy(w, req)
}))
defer s.Close()
config, _ := websocket.NewConfig("ws://"+addr, "http://"+addr)
config.Protocol = protocols
client, err := websocket.DialConfig(config)
if err != nil {
return nil, err
}
defer client.Close()
if fn != nil {
fn(client)
}
data, err := ioutil.ReadAll(client)
if err != nil {
return data, err
}
return data, <-errCh
}
func readWebSocket(r *Reader, t *testing.T, fn func(*websocket.Conn), protocols ...string) ([]byte, error) {
errCh := make(chan error, 1)
s, addr := newServer(func(ws *websocket.Conn) {
cfg := ws.Config()
cfg.Protocol = protocols
go func() {
err := <-r.err
errCh <- err
}()
r.handle(ws)
})
defer s.Close()
config, _ := websocket.NewConfig("ws://"+addr, "http://"+addr)
client, err := websocket.DialConfig(config)
if err != nil {
return nil, err
}
defer client.Close()
if fn != nil {
fn(client)
}
data, err := ioutil.ReadAll(client)
if err != nil {
return data, err
}
return data, <-errCh
}
func createWebsocketDialer(cfg *websocket.Config, opts DialOpts) func(<-chan struct{}) (io.Closer, error) {
openAttempt := utils.AttemptStrategy{
Total: opts.Timeout,
Delay: opts.RetryDelay,
}
return func(stop <-chan struct{}) (io.Closer, error) {
for a := openAttempt.Start(); a.Next(); {
select {
case <-stop:
return nil, parallel.ErrStopped
default:
}
logger.Infof("dialing %q", cfg.Location)
conn, err := websocket.DialConfig(cfg)
if err == nil {
return conn, nil
}
if a.HasNext() {
logger.Debugf("error dialing %q, will retry: %v", cfg.Location, err)
} else {
logger.Infof("error dialing %q: %v", cfg.Location, err)
return nil, errors.Errorf("unable to connect to %q", cfg.Location)
}
}
panic("unreachable")
}
}
func expectWebSocketFrames(r *Reader, t *testing.T, fn func(*websocket.Conn), frames [][]byte, protocols ...string) error {
errCh := make(chan error, 1)
s, addr := newServer(http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
errCh <- r.Copy(w, req)
}))
defer s.Close()
config, _ := websocket.NewConfig("ws://"+addr, "http://"+addr)
config.Protocol = protocols
ws, err := websocket.DialConfig(config)
if err != nil {
return err
}
defer ws.Close()
if fn != nil {
fn(ws)
}
for i := range frames {
var data []byte
if err := websocket.Message.Receive(ws, &data); err != nil {
return err
}
if !reflect.DeepEqual(frames[i], data) {
return fmt.Errorf("frame %d did not match expected: %v", data, err)
}
}
var data []byte
if err := websocket.Message.Receive(ws, &data); err != io.EOF {
return fmt.Errorf("expected no more frames: %v (%v)", err, data)
}
return <-errCh
}
func createWebsocketDialer(cfg *websocket.Config, opts DialOpts) func(<-chan struct{}) (io.Closer, error) {
// TODO(katco): 2016-08-09: lp:1611427
openAttempt := utils.AttemptStrategy{
Total: opts.Timeout,
Delay: opts.RetryDelay,
}
return func(stop <-chan struct{}) (io.Closer, error) {
for a := openAttempt.Start(); a.Next(); {
select {
case <-stop:
return nil, parallel.ErrStopped
default:
}
logger.Infof("dialing %q", cfg.Location)
conn, err := websocket.DialConfig(cfg)
if err == nil {
return conn, nil
}
if !a.HasNext() || isX509Error(err) {
// We won't reconnect when there's an X509 error
// because we're not going to succeed if we retry
// in that case.
logger.Infof("error dialing %q: %v", cfg.Location, err)
return nil, errors.Annotatef(err, "unable to connect to API")
}
}
panic("unreachable")
}
}
func testWebSocketServer(hdrs map[string]string, expected string) {
origin := "http://127.0.0.1/"
url := "ws://" + string(_defaultFrontdAddr) + "/echo"
cfg, err := websocket.NewConfig(url, origin)
if err != nil {
panic(err)
}
for k, v := range hdrs {
cfg.Header.Set(k, v)
}
ws, err := websocket.DialConfig(cfg)
if err != nil {
panic(err)
}
if _, err := ws.Write([]byte(expected)); err != nil {
panic(err)
}
var msg = make([]byte, len(expected))
var n int
if n, err = ws.Read(msg); err != nil {
panic(err)
}
if expected != string(msg[:n]) {
log.Println(string(msg[:n]))
log.Println(expected)
panic(fmt.Errorf("websocket reply not match: %s", string(msg[:n])))
}
}
func cli(args CommandLineArguments, wg *sync.WaitGroup) {
defer wg.Done()
cfg, err := websocket.NewConfig(args.server, "wss://localhost")
if err != nil {
panic(err)
}
cert, err := tls.LoadX509KeyPair("server.pem", "server.key")
if err != nil {
panic(err)
}
config := tls.Config{Certificates: []tls.Certificate{cert}}
config.InsecureSkipVerify = true
cfg.TlsConfig = &config
ws, err := websocket.DialConfig(cfg)
if err != nil {
panic(err)
}
if args.msg != "" {
log.Println("Write data to websocket")
_, err = ws.Write([]byte(args.msg))
if err != nil {
panic(err)
}
}
if args.file != "" {
go func() {
f, err := os.Open(args.file)
if err != nil {
panic(err)
}
defer f.Close()
s := bufio.NewScanner(f)
for s.Scan() {
time.Sleep(time.Duration(args.delay) * time.Second)
_, err = ws.Write([]byte(s.Text()))
if err != nil {
panic(err)
}
}
}()
}
ws.SetReadDeadline(time.Now().Add(time.Second * time.Duration(args.timeOut)))
msgOut := make([]byte, 16384)
for {
n, err := ws.Read(msgOut)
log.Println("Read bytes:", n)
if err == io.EOF {
log.Println("Reading finished")
break
}
if err != nil {
log.Println(err)
break
}
log.Println(string(msgOut[:n]))
}
log.Println("Closing connection")
ws.Close()
}
func TestBase64Conn(t *testing.T) {
conn := NewConn(NewDefaultChannelProtocols([]ChannelType{ReadWriteChannel, ReadWriteChannel}))
s, addr := newServer(http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
conn.Open(w, req)
}))
defer s.Close()
config, err := websocket.NewConfig("ws://"+addr, "http://localhost/")
if err != nil {
t.Fatal(err)
}
config.Protocol = []string{"base64.channel.k8s.io"}
client, err := websocket.DialConfig(config)
if err != nil {
t.Fatal(err)
}
defer client.Close()
<-conn.ready
wg := sync.WaitGroup{}
wg.Add(1)
go func() {
defer wg.Done()
data, err := ioutil.ReadAll(conn.channels[0])
if err != nil {
t.Fatal(err)
}
if !reflect.DeepEqual(data, []byte("client")) {
t.Errorf("unexpected server read: %s", string(data))
}
}()
clientData := base64.StdEncoding.EncodeToString([]byte("client"))
if n, err := client.Write(append([]byte{'0'}, clientData...)); err != nil || n != len(clientData)+1 {
t.Fatalf("%d: %v", n, err)
}
wg.Add(1)
go func() {
defer wg.Done()
if n, err := conn.channels[1].Write([]byte("server")); err != nil && n != 6 {
t.Fatalf("%d: %v", n, err)
}
}()
data := make([]byte, 1024)
if n, err := io.ReadAtLeast(client, data, 9); n != 9 || err != nil {
t.Fatalf("%d: %v", n, err)
}
expect := []byte(base64.StdEncoding.EncodeToString([]byte("server")))
if !reflect.DeepEqual(data[:9], append([]byte{'1'}, expect...)) {
t.Errorf("unexpected client read: %v", data[:9])
}
client.Close()
wg.Wait()
}
func TestBase64Conn(t *testing.T) {
conn := NewConn(ReadWriteChannel, ReadWriteChannel)
// TODO: Uncomment next two lines and remove third line when fix #19254
// s, addr := newServer(conn.handle)
// defer s.Close()
_, addr := newServer(conn.handle)
config, err := websocket.NewConfig("ws://"+addr, "http://localhost/")
if err != nil {
t.Fatal(err)
}
config.Protocol = []string{"base64.channel.k8s.io"}
client, err := websocket.DialConfig(config)
if err != nil {
t.Fatal(err)
}
defer client.Close()
<-conn.ready
wg := sync.WaitGroup{}
wg.Add(1)
go func() {
defer wg.Done()
data, err := ioutil.ReadAll(conn.channels[0])
if err != nil {
t.Fatal(err)
}
if !reflect.DeepEqual(data, []byte("client")) {
t.Errorf("unexpected server read: %s", string(data))
}
}()
clientData := base64.StdEncoding.EncodeToString([]byte("client"))
if n, err := client.Write(append([]byte{'0'}, clientData...)); err != nil || n != len(clientData)+1 {
t.Fatalf("%d: %v", n, err)
}
wg.Add(1)
go func() {
defer wg.Done()
if n, err := conn.channels[1].Write([]byte("server")); err != nil && n != 6 {
t.Fatalf("%d: %v", n, err)
}
}()
data := make([]byte, 1024)
if n, err := io.ReadAtLeast(client, data, 9); n != 9 || err != nil {
t.Fatalf("%d: %v", n, err)
}
expect := []byte(base64.StdEncoding.EncodeToString([]byte("server")))
if !reflect.DeepEqual(data[:9], append([]byte{'1'}, expect...)) {
t.Errorf("unexpected client read: %v", data[:9])
}
client.Close()
wg.Wait()
}
func main() {
if *user == "" {
log.Fatalf("No user/pass\n")
}
originURL, err := url.Parse("https://" + *ipAddress + "/api/v1/watch/namespaces/decap/pods?watch=true&labelSelector=type=decap-build")
if err != nil {
log.Fatal(err)
}
serviceURL, err := url.Parse("wss://" + *ipAddress + "/api/v1/watch/namespaces/decap/pods?watch=true&labelSelector=type=decap-build")
if err != nil {
log.Fatal(err)
}
cfg := websocket.Config{
Location: serviceURL,
Origin: originURL,
TlsConfig: &tls.Config{InsecureSkipVerify: true},
Header: map[string][]string{"Authorization": []string{"Basic " + base64.StdEncoding.EncodeToString([]byte(*user+":"+*password))}},
Version: websocket.ProtocolVersionHybi13,
}
conn, err := websocket.DialConfig(&cfg)
if err != nil {
log.Fatalf("Error opening connection: %v\n", err)
}
// returns a Pod Object
var msg string
for {
err := websocket.Message.Receive(conn, &msg)
if err != nil {
if err == io.EOF {
break
}
log.Println("Couldn't receive msg " + err.Error())
break
}
var pod Pod
if err := json.Unmarshal([]byte(msg), &pod); err != nil {
log.Println(err)
continue
}
var deletePod bool
for _, status := range pod.Object.Status.Statuses {
if status.Name == "build-server" && status.State.Terminated.ContainerID != "" {
deletePod = true
break
}
}
if deletePod {
log.Printf("Would delete: %+v\n", pod)
}
}
os.Exit(0)
}
// Register target type on vmt server and start to listen for server message
func (wsc *WebSocketCommunicator) RegisterAndListen(registrationMessage *MediationClientMessage) {
// vmtServerUrl := "ws://10.10.173.154:8080/vmturbo/remoteMediation"
vmtServerUrl := "ws://" + wsc.VmtServerAddress + "/vmturbo/remoteMediation"
localAddr := wsc.LocalAddress
glog.V(3).Infof("Dial Server: %s", vmtServerUrl)
config, err := websocket.NewConfig(vmtServerUrl, localAddr)
if err != nil {
glog.Fatal(err)
}
usrpasswd := []byte(wsc.ServerUsername + ":" + wsc.ServerPassword)
config.Header = http.Header{
"Authorization": {"Basic " + base64.StdEncoding.EncodeToString(usrpasswd)},
}
webs, err := websocket.DialConfig(config)
// webs, err := websocket.Dial(vmtServerUrl, "", localAddr)
if err != nil {
glog.Error(err)
if webs == nil {
glog.Error("The websocket is null, reset")
}
wsc.CloseAndRegisterAgain(registrationMessage)
}
wsc.ws = webs
glog.V(3).Infof("Send registration info")
wsc.SendClientMessage(registrationMessage)
var msg = make([]byte, 1024)
var n int
// main loop for listening server message.
for {
if n, err = wsc.ws.Read(msg); err != nil {
glog.Error(err)
//glog.Fatal(err.Error())
//re-establish connection when error
glog.V(3).Infof("Error happened, re-establish websocket connection")
break
}
serverMsg := &MediationServerMessage{}
err = proto.Unmarshal(msg[:n], serverMsg)
if err != nil {
glog.Error("Received unmarshalable error, please make sure you are running the latest VMT server")
glog.Fatal("unmarshaling error: ", err)
}
//Spawn a separate go routine to handle the server message
go wsc.handleServerMessage(serverMsg, registrationMessage)
glog.V(3).Infof("Continue listen from server...")
}
wsc.CloseAndRegisterAgain(registrationMessage)
}
// Console opens a secure console to a code or database service. For code
// services, a command is required. This command is executed as root in the
// context of the application root directory. For database services, no command
// is needed - instead, the appropriate command for the database type is run.
// For example, for a postgres database, psql is run.
func Console(serviceLabel string, command string, settings *models.Settings) {
helpers.SignIn(settings)
service := helpers.RetrieveServiceByLabel(serviceLabel, settings)
if service == nil {
fmt.Printf("Could not find a service with the label \"%s\"\n", serviceLabel)
os.Exit(1)
}
fmt.Printf("Opening console to %s (%s)\n", serviceLabel, service.ID)
task := helpers.RequestConsole(command, service.ID, settings)
fmt.Print("Waiting for the console to be ready. This might take a minute.")
ch := make(chan string, 1)
go helpers.PollConsoleJob(task.ID, service.ID, ch, settings)
jobID := <-ch
defer helpers.DestroyConsole(jobID, service.ID, settings)
creds := helpers.RetrieveConsoleTokens(jobID, service.ID, settings)
creds.URL = strings.Replace(creds.URL, "http", "ws", 1)
fmt.Println("Connecting...")
// BEGIN websocket impl
config, _ := websocket.NewConfig(creds.URL, "ws://localhost:9443/")
config.TlsConfig = &tls.Config{
MinVersion: tls.VersionTLS12,
}
config.Header["X-Console-Token"] = []string{creds.Token}
ws, err := websocket.DialConfig(config)
if err != nil {
panic(err)
}
defer ws.Close()
fmt.Println("Connection opened")
stdin, stdout, _ := term.StdStreams()
fdIn, isTermIn := term.GetFdInfo(stdin)
if !isTermIn {
panic(errors.New("StdIn is not a terminal"))
}
oldState, err := term.SetRawTerminal(fdIn)
if err != nil {
panic(err)
}
done := make(chan bool)
msgCh := make(chan []byte, 2)
go webSocketDaemon(ws, &stdout, done, msgCh)
signal.Notify(make(chan os.Signal, 1), os.Interrupt)
defer term.RestoreTerminal(fdIn, oldState)
go termDaemon(&stdin, ws)
<-done
}
func dialWebsocket(c *gc.C, addr, path string) (*websocket.Conn, error) {
origin := "http://localhost/"
url := fmt.Sprintf("wss://%s%s", addr, path)
config, err := websocket.NewConfig(url, origin)
c.Assert(err, jc.ErrorIsNil)
pool := x509.NewCertPool()
xcert, err := cert.ParseCert(coretesting.CACert)
c.Assert(err, jc.ErrorIsNil)
pool.AddCert(xcert)
config.TlsConfig = &tls.Config{RootCAs: pool}
return websocket.DialConfig(config)
}
func (c *Client) Stream(path string, headers map[string]string, in io.Reader, out io.Writer) error {
origin := fmt.Sprintf("https://%s", c.Host)
url := fmt.Sprintf("wss://%s%s", c.Host, path)
config, err := websocket.NewConfig(url, origin)
if err != nil {
return err
}
config.TlsConfig = &tls.Config{
InsecureSkipVerify: true,
}
config.Header.Set("Version", c.Version)
userpass := fmt.Sprintf("convox:%s", c.Password)
userpass_encoded := base64.StdEncoding.EncodeToString([]byte(userpass))
config.Header.Add("Authorization", fmt.Sprintf("Basic %s", userpass_encoded))
for k, v := range headers {
config.Header.Add(k, v)
}
config.TlsConfig = &tls.Config{
InsecureSkipVerify: true,
}
ws, err := websocket.DialConfig(config)
if err != nil {
return err
}
defer ws.Close()
var wg sync.WaitGroup
if in != nil {
go copyAsync(ws, in, nil)
}
if out != nil {
wg.Add(1)
go copyAsync(out, ws, &wg)
}
wg.Wait()
return nil
}
func newWebsocketClient(c *gc.C, cfg *websocket.Config) *websocket.Conn {
client, err := websocket.DialConfig(cfg)
if err == nil {
return client
}
timeoutCh := time.After(coretesting.LongWait)
for {
select {
case <-timeoutCh:
c.Assert(err, jc.ErrorIsNil)
case <-time.After(coretesting.ShortWait):
}
client, err = websocket.DialConfig(cfg)
if _, ok := err.(*websocket.DialError); ok {
continue
}
c.Assert(err, jc.ErrorIsNil)
return client
}
}
func dial(url, protocol, origin string) (ws *websocket.Conn, err error) {
config, err := websocket.NewConfig(url, origin)
if err != nil {
return nil, err
}
if protocol != "" {
config.Protocol = []string{protocol}
}
config.TlsConfig = &tls.Config{
InsecureSkipVerify: insecureSkipVerify,
}
return websocket.DialConfig(config)
}
func (s *S) TestAppShellSpecifyUnit(c *check.C) {
a := app.App{
Name: "someapp",
Platform: "zend",
Teams: []string{s.team.Name},
}
err := s.conn.Apps().Insert(a)
c.Assert(err, check.IsNil)
defer s.conn.Apps().Remove(bson.M{"name": a.Name})
defer s.logConn.Logs(a.Name).DropCollection()
err = s.provisioner.Provision(&a)
c.Assert(err, check.IsNil)
defer s.provisioner.Destroy(&a)
s.provisioner.AddUnits(&a, 5, "web", nil)
units, err := s.provisioner.Units(&a)
c.Assert(err, check.IsNil)
unit := units[3]
m := RunServer(true)
server := httptest.NewServer(m)
defer server.Close()
testServerURL, err := url.Parse(server.URL)
c.Assert(err, check.IsNil)
url := fmt.Sprintf("ws://%s/apps/%s/shell?width=140&height=38&term=xterm&unit=%s", testServerURL.Host, a.Name, unit.ID)
config, err := websocket.NewConfig(url, "ws://localhost/")
c.Assert(err, check.IsNil)
config.Header.Set("Authorization", "bearer "+s.token.GetValue())
wsConn, err := websocket.DialConfig(config)
c.Assert(err, check.IsNil)
defer wsConn.Close()
_, err = wsConn.Write([]byte("echo test"))
c.Assert(err, check.IsNil)
var shells []provision.ShellOptions
err = tsurutest.WaitCondition(5*time.Second, func() bool {
shells = s.provisioner.Shells(unit.ID)
return len(shells) == 1
})
c.Assert(err, check.IsNil)
c.Assert(shells, check.HasLen, 1)
c.Assert(shells[0].App.GetName(), check.Equals, a.Name)
c.Assert(shells[0].Width, check.Equals, 140)
c.Assert(shells[0].Height, check.Equals, 38)
c.Assert(shells[0].Term, check.Equals, "xterm")
c.Assert(shells[0].Unit, check.Equals, unit.ID)
units, err = s.provisioner.Units(&a)
c.Assert(err, check.IsNil)
for _, u := range units {
if u.ID != unit.ID {
c.Check(s.provisioner.Shells(u.ID), check.HasLen, 0)
}
}
}
//connect connects to the server
func (ws *bot) connect() {
//setup new config prior to connection
conf, err := websocket.NewConfig(ws.url, ws.origin)
if err != nil {
panic(err)
}
//Add the token for connection
conf.Header.Add("Cookie", "authtoken="+ws.token+";")
ws.conn, err = websocket.DialConfig(conf)
if err != nil {
panic(err)
}
}
func (c *SessionClient) dialWebsocket(service string, action string) (*websocket.Conn, error) {
var origin string
var wsurl string
useTls := false
if c.Origin == "" {
origin = "http://localhost"
} else {
origin = c.Origin
}
if c.WSURL == "" {
burl, err := url.Parse(c.APIURL)
if err != nil {
return nil, err
}
if burl.Scheme == "https" {
burl.Scheme = "wss"
useTls = true
} else {
burl.Scheme = "ws"
}
wsurl = burl.String()
} else {
wsurl = c.WSURL
}
conf, err := websocket.NewConfig(wsurl, origin)
if err != nil {
return nil, err
}
conf.Protocol = []string{"binary"}
conf.Location.Path = fmt.Sprintf(
c.Prefix+"/session/%s/conn/%s%s/websocket", c.ID, service, action,
)
//TODO use root cert
if useTls {
conf.TlsConfig = c.TLSConfig
}
wsconn, err := websocket.DialConfig(conf)
if err != nil {
return nil, err
}
return wsconn, nil
}
func main() {
flag.Parse()
url := fmt.Sprintf("ws://localhost:9000/ws?user=%s&room=%s", userName, room)
wsConfig, err := websocket.NewConfig(url, "http://localhost:9000")
if err != nil {
fmt.Println("error : ", err.Error())
return
}
wsConn, err := websocket.DialConfig(wsConfig)
if err != nil {
fmt.Println("conn error: ", err.Error())
return
}
read := make(chan int)
//for read
go func() {
for {
var message string
if err := websocket.Message.Receive(wsConn, &message); err != nil {
if err == io.EOF {
fmt.Println("conn broken,bye!")
break
}
fmt.Println("receive error : ", err.Error())
continue
}
fmt.Printf(" received: %s\n", message)
read <- 1
}
}()
for i := 0; i < 10; i++ {
msg := userName + " : " + "i am comming "
msg = fmt.Sprintf("%s %d", msg, i)
err := websocket.Message.Send(wsConn, msg)
if err != nil {
fmt.Println("send failed!")
}
fmt.Println("send success,wait read")
<-read
}
}
func TestWebSocketPing(t *testing.T) {
config := tls.Config{
Certificates: []tls.Certificate{*user1cert},
InsecureSkipVerify: true,
}
wsCfg1.TlsConfig = &config
ws, err := websocket.DialConfig(wsCfg1)
assert.NoError(t, err)
_, err = ws.Write([]byte("ping"))
assert.NoError(t, err)
msg := make([]byte, 512)
var n int
n, err = ws.Read(msg)
assert.NoError(t, err)
assert.Equal(t, "pong", string(msg[:n]))
}
func WebsocketTLS_Client() {
caCrt, err := ioutil.ReadFile(CACertFile)
if err != nil {
log.Fatal("[WebsocketTLS_Client] ReadFile err:", err)
}
cliCrt, err := tls.LoadX509KeyPair(CliCertFile, CliKeyFile)
if err != nil {
log.Fatal("[WebsocketTLS_Client] Loadx509keypair err:", err)
}
pool := x509.NewCertPool()
pool.AppendCertsFromPEM(caCrt)
origin := fmt.Sprintf("https://%s", BindUrl)
url := fmt.Sprintf("wss://%s", BindUrl)
conf, err := websocket.NewConfig(url, origin)
if err != nil {
log.Fatal("[WebsocketTLS_Client] NewConfig err:", err)
}
conf.TlsConfig = &tls.Config{
RootCAs: pool,
ServerName: BindSrvName,
Certificates: []tls.Certificate{cliCrt},
}
ws, err := websocket.DialConfig(conf)
if err != nil {
log.Fatal("[WebsocketTLS_Client] DialConfig err:", err)
}
if _, err := ws.Write([]byte("Hello World!")); err != nil {
log.Fatal("[WebsocketTLS_Client] Write err:", err)
} else {
log.Println("[WebsocketTLS_Client] Write succeed!")
}
var n int
for {
var msg = make([]byte, 512)
if n, err = ws.Read(msg); err != nil {
log.Fatal("[WebsocketTLS_Client] Read:", err)
}
log.Println("[WebsocketTLS_Client] Received: %s.\n", msg[:n])
}
}
func TestStreamVersionedCopy(t *testing.T) {
for i, test := range versionTests() {
func() {
supportedProtocols := map[string]ReaderProtocolConfig{}
for p, binary := range test.supported {
supportedProtocols[p] = ReaderProtocolConfig{
Binary: binary,
}
}
input := "some random text"
r := NewReader(bytes.NewBuffer([]byte(input)), true, supportedProtocols)
s, addr := newServer(http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
err := r.Copy(w, req)
if err != nil {
w.WriteHeader(503)
}
}))
defer s.Close()
config, err := websocket.NewConfig("ws://"+addr, "http://localhost/")
if err != nil {
t.Error(err)
return
}
config.Protocol = test.requested
client, err := websocket.DialConfig(config)
if err != nil {
if !test.error {
t.Errorf("test %d: didn't expect error: %v", i, err)
}
return
}
defer client.Close()
if test.error && err == nil {
t.Errorf("test %d: expected an error", i)
return
}
<-r.err
if got, expected := r.selectedProtocol, test.expected; got != expected {
t.Errorf("test %d: unexpected protocol version: got=%s expected=%s", i, got, expected)
}
}()
}
}
func TestVersionedConn(t *testing.T) {
for i, test := range versionTests() {
func() {
supportedProtocols := map[string]ChannelProtocolConfig{}
for p, binary := range test.supported {
supportedProtocols[p] = ChannelProtocolConfig{
Binary: binary,
Channels: []ChannelType{ReadWriteChannel},
}
}
conn := NewConn(supportedProtocols)
// note that it's not enough to wait for conn.ready to avoid a race here. Hence,
// we use a channel.
selectedProtocol := make(chan string, 0)
s, addr := newServer(http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
p, _, _ := conn.Open(w, req)
selectedProtocol <- p
}))
defer s.Close()
config, err := websocket.NewConfig("ws://"+addr, "http://localhost/")
if err != nil {
t.Fatal(err)
}
config.Protocol = test.requested
client, err := websocket.DialConfig(config)
if err != nil {
if !test.error {
t.Fatalf("test %d: didn't expect error: %v", i, err)
} else {
return
}
}
defer client.Close()
if test.error && err == nil {
t.Fatalf("test %d: expected an error", i)
}
<-conn.ready
if got, expected := <-selectedProtocol, test.expected; got != expected {
t.Fatalf("test %d: unexpected protocol version: got=%s expected=%s", i, got, expected)
}
}()
}
}
func main() {
config, err := websocket.NewConfig(url, origin)
config.Header["accesskey"] = []string{"gNV/bxhxG)IrvEeaZK_mA2HkCxC2yu!bHjGK!(MLNQ1tuDnUKyGBL9G/rGhXHNzU"}
ws, err := websocket.DialConfig(config)
if err != nil {
log.Fatal(err)
}
for {
var msg = make([]byte, 512)
_, err = ws.Read(msg)
if err != nil {
log.Fatal(err)
}
fmt.Printf("Receive: %s\n", msg)
}
}
