// Connect opens a connection to the backend and upgrades it to a websocket. Calls to
// 'MakeRequest' can be made after calling this, but responss will not be
// receivable until 'Serve' is also called.
func (cs *ClientServerImpl) Connect() error {
parsedURL, err := url.Parse(cs.URL)
if err != nil {
return err
}
// NewRequest never returns an error if the url parses and we just verified
// it did above
request, _ := http.NewRequest("GET", cs.URL, nil)
// Sign the request; we'll send its headers via the websocket client which includes the signature
utils.SignHTTPRequest(request, cs.Region, ServiceName, cs.CredentialProvider)
// url.Host might not have the port, but tls.Dial needs it
dialHost := parsedURL.Host
if !strings.Contains(dialHost, ":") {
dialHost += ":443"
}
timeoutDialer := &net.Dialer{Timeout: wsConnectTimeout}
log.Info("Creating poll dialer", "host", parsedURL.Host)
wsConn, err := tls.DialWithDialer(timeoutDialer, "tcp", dialHost, &tls.Config{InsecureSkipVerify: cs.AcceptInvalidCert})
if err != nil {
return err
}
websocketConn, httpResponse, err := websocket.NewClient(wsConn, parsedURL, request.Header, readBufSize, writeBufSize)
if httpResponse != nil {
defer httpResponse.Body.Close()
}
if err != nil {
defer wsConn.Close()
var resp []byte
if httpResponse != nil {
var readErr error
resp, readErr = ioutil.ReadAll(httpResponse.Body)
if readErr != nil {
return errors.New("Unable to read websocket connection: " + readErr.Error() + ", " + err.Error())
}
// If there's a response, we can try to unmarshal it into one of the
// modeled error types
possibleError, _, decodeErr := DecodeData(resp, cs.TypeDecoder)
if decodeErr == nil {
return cs.NewError(possibleError)
}
}
log.Warn("Error creating a websocket client", "err", err)
return errors.New(string(resp) + ", " + err.Error())
}
cs.Conn = websocketConn
return nil
}
func (cs *clientServer) signRequest(payload []byte) []byte {
reqBody := bytes.NewBuffer(payload)
// NewRequest never returns an error if the url parses and we just verified
// it did above
request, _ := http.NewRequest("GET", cs.URL, reqBody)
utils.SignHTTPRequest(request, cs.Region, "ecs", cs.CredentialProvider, aws.ReadSeekCloser(reqBody))
request.Header.Add("Host", request.Host)
var dataBuffer bytes.Buffer
request.Header.Write(&dataBuffer)
io.WriteString(&dataBuffer, "\r\n")
data := dataBuffer.Bytes()
data = append(data, payload...)
return data
}
// Connect opens a connection to the backend and upgrades it to a websocket. Calls to
// 'MakeRequest' can be made after calling this, but responss will not be
// receivable until 'Serve' is also called.
func (cs *ClientServerImpl) Connect() error {
parsedURL, err := url.Parse(cs.URL)
if err != nil {
return err
}
// NewRequest never returns an error if the url parses and we just verified
// it did above
request, _ := http.NewRequest("GET", cs.URL, nil)
// Sign the request; we'll send its headers via the websocket client which includes the signature
utils.SignHTTPRequest(request, cs.Region, ServiceName, cs.CredentialProvider, nil)
wsConn, err := cs.websocketConn(parsedURL, request)
if err != nil {
return err
}
websocketConn, httpResponse, err := websocket.NewClient(wsConn, parsedURL, request.Header, readBufSize, writeBufSize)
if httpResponse != nil {
defer httpResponse.Body.Close()
}
if err != nil {
defer wsConn.Close()
var resp []byte
if httpResponse != nil {
var readErr error
resp, readErr = ioutil.ReadAll(httpResponse.Body)
if readErr != nil {
return errors.New("Unable to read websocket connection: " + readErr.Error() + ", " + err.Error())
}
// If there's a response, we can try to unmarshal it into one of the
// modeled error types
possibleError, _, decodeErr := DecodeData(resp, cs.TypeDecoder)
if decodeErr == nil {
return cs.NewError(possibleError)
}
}
log.Warn("Error creating a websocket client", "err", err)
return errors.New(string(resp) + ", " + err.Error())
}
cs.Conn = websocketConn
return nil
}
func (cs *clientServer) signRequest(payload []byte) []byte {
reqBody := bytes.NewBuffer(payload)
// NewRequest never returns an error if the url parses and we just verified
// it did above
request, _ := http.NewRequest("GET", cs.URL, reqBody)
utils.SignHTTPRequest(request, cs.Region, "ecs", cs.CredentialProvider)
var data []byte
for k, vs := range request.Header {
for _, v := range vs {
data = append(data, k...)
data = append(data, ": "...)
data = append(data, v...)
data = append(data, "\r\n"...)
}
}
data = append(data, "\r\n"...)
data = append(data, payload...)
return data
}
