Change AgentConfig to WSClientMinAgentConfig, export cfg in ClientServerImpl struct, use logger instead of seelog

Author: Richa Gangwar

ecs-agent/wsclient/client.go

@@ -41,7 +41,6 @@ import (
 
 	"github.com/aws/aws-sdk-go/aws/credentials"
 	"github.com/aws/aws-sdk-go/private/protocol/json/jsonutil"
-	"github.com/cihub/seelog"
 	"github.com/gorilla/websocket"
 	"github.com/pkg/errors"
 )
@@ -68,7 +67,7 @@ const (
 
 	errClosed = "use of closed network connection"
 
-	// ExitTerminal indicates the containerd agent run into error that's not recoverable
+	// ExitTerminal indicates the agent run into error that's not recoverable
 	// no need to restart
 	ExitTerminal = 5
 )
@@ -154,7 +153,7 @@ type ClientServer interface {
 // AgentConfig is a subset of agent's config. Since this requires agent specific information,
 // making this as a struct to be passed from the individual agents while using the wsclient shared lib.
 // The agent where the field is not applicable can be left empty
-type AgentConfig struct {
+type WSClientMinAgentConfig struct {
 	AWSRegion          string
 	AcceptInsecureCert bool
 	DockerEndpoint     string
@@ -163,8 +162,8 @@ type AgentConfig struct {
 
 // ClientServerImpl wraps commonly used methods defined in ClientServer interface.
 type ClientServerImpl struct {
-	// cfg is the subset of user-specified runtime configuration
-	cfg *AgentConfig
+	// Cfg is the subset of user-specified runtime configuration
+	Cfg *WSClientMinAgentConfig
 	// conn holds the underlying low-level websocket connection
 	conn wsconn.WebsocketConn
 	// CredentialProvider is used to retrieve AWS credentials
@@ -220,31 +219,31 @@ func (cs *ClientServerImpl) Connect() error {
 	request, _ := http.NewRequest("GET", parsedURL.String(), nil)
 
 	// Sign the request; we'll send its headers via the websocket client which includes the signature
-	err = utils.SignHTTPRequest(request, cs.cfg.AWSRegion, ServiceName, cs.CredentialProvider, nil)
+	err = utils.SignHTTPRequest(request, cs.Cfg.AWSRegion, ServiceName, cs.CredentialProvider, nil)
 	if err != nil {
 		return err
 	}
 
 	timeoutDialer := &net.Dialer{Timeout: wsConnectTimeout}
-	tlsConfig := &tls.Config{ServerName: parsedURL.Host, InsecureSkipVerify: cs.cfg.AcceptInsecureCert, MinVersion: tls.VersionTLS12}
+	tlsConfig := &tls.Config{ServerName: parsedURL.Host, InsecureSkipVerify: cs.Cfg.AcceptInsecureCert, MinVersion: tls.VersionTLS12}
 
 	//TODO: In order to get rid of the check -
 	// 1. Remove the hardcoded cipher suites, and rely on default by tls package
 	// 2. NO_PROXY should be set as part of config check or in init somewhere. Wsclient is not the right place.
-	if cs.cfg.IsDocker {
+	if cs.Cfg.IsDocker {
 
 		cipher.WithSupportedCipherSuites(tlsConfig)
 
 		// Ensure that NO_PROXY gets set
 		noProxy := os.Getenv("NO_PROXY")
 		if noProxy == "" {
-			dockerHost, err := url.Parse(cs.cfg.DockerEndpoint)
+			dockerHost, err := url.Parse(cs.Cfg.DockerEndpoint)
 			if err == nil {
 				dockerHost.Scheme = ""
 				os.Setenv("NO_PROXY", fmt.Sprintf("%s,%s", defaultNoProxyIP, dockerHost.String()))
-				seelog.Info("NO_PROXY set:", os.Getenv("NO_PROXY"))
+				logger.Info(fmt.Sprintf("NO_PROXY is set: %s", os.Getenv("NO_PROXY")))
 			} else {
-				seelog.Errorf("NO_PROXY unable to be set: the configured Docker endpoint is invalid.")
+				logger.Error("NO_PROXY unable to be set: the configured Docker endpoint is invalid.")
 			}
 		}
 	}
@@ -278,7 +277,7 @@ func (cs *ClientServerImpl) Connect() error {
 				return cs.NewError(possibleError)
 			}
 		}
-		seelog.Warnf("Error creating a websocket client: %v", err)
+		logger.Warn(fmt.Sprintf("Error creating a websocket client: %v", err))
 		return errors.Wrapf(err, "websocket client: unable to dial %s response: %s",
 			parsedURL.Host, string(resp))
 	}
@@ -287,7 +286,7 @@ func (cs *ClientServerImpl) Connect() error {
 	defer cs.writeLock.Unlock()
 
 	cs.conn = websocketConn
-	seelog.Debugf("Established a Websocket connection to %s", cs.URL)
+	logger.Debug(fmt.Sprintf("Established a Websocket connection to %s", cs.URL))
 	return nil
 }
 
@@ -314,11 +313,11 @@ func (cs *ClientServerImpl) SetReadDeadline(t time.Time) error {
 	if err == nil {
 		return nil
 	}
-	seelog.Warnf("Unable to set read deadline for websocket connection: %v for %s", err, cs.URL)
+	logger.Warn(fmt.Sprintf("Unable to set read deadline for websocket connection: %v for %s", err, cs.URL))
 	// If we get connection closed error from SetReadDeadline, break out of the for loop and
 	// return an error
 	if opErr, ok := err.(*net.OpError); ok && strings.Contains(opErr.Err.Error(), errClosed) {
-		seelog.Errorf("Stopping redundant reads on closed network connection: %s", cs.URL)
+		logger.Error(fmt.Sprintf("Stopping redundant reads on closed network connection: %s", cs.URL))
 		return opErr
 	}
 	// An unhandled error has occurred while trying to extend read deadline.
@@ -339,13 +338,13 @@ func (cs *ClientServerImpl) forceCloseConnection() {
 	select {
 	case closeErr := <-closeChan:
 		if closeErr != nil {
-			seelog.Warnf("Unable to close websocket connection: %v for %s",
-				closeErr, cs.URL)
+			logger.Warn(fmt.Sprintf("Unable to close websocket connection: %v for %s",
+				closeErr, cs.URL))
 		}
 	case <-ctx.Done():
 		if ctx.Err() != nil {
-			seelog.Warnf("Context canceled waiting for termination of websocket connection: %v for %s",
-				ctx.Err(), cs.URL)
+			logger.Warn(fmt.Sprintf("Context canceled waiting for termination of websocket connection: %v for %s",
+				ctx.Err(), cs.URL))
 		}
 	}
 }
@@ -363,7 +362,7 @@ func (cs *ClientServerImpl) Disconnect(...interface{}) error {
 	// as the close frame needs to be sent to the server. Set the deadline
 	// for that as well.
 	if err := cs.conn.SetWriteDeadline(time.Now().Add(cs.RWTimeout)); err != nil {
-		seelog.Warnf("Unable to set write deadline for websocket connection: %v for %s", err, cs.URL)
+		logger.Warn(fmt.Sprintf("Unable to set write deadline for websocket connection: %v for %s", err, cs.URL))
 	}
 	return cs.conn.Close()
 }
@@ -386,7 +385,8 @@ func (cs *ClientServerImpl) AddRequestHandler(f RequestHandler) {
 	recognizedTypes := cs.GetRecognizedTypes()
 	_, ok := recognizedTypes[firstArgTypeStr]
 	if !ok {
-		seelog.Errorf("Invalid Handler. AddRequestHandler called with invalid function; argument type not recognized: %v", firstArgTypeStr)
+		logger.Error(fmt.Sprintf("Invalid Handler. AddRequestHandler called with invalid function; "+
+			"argument type not recognized: %v", firstArgTypeStr))
 		os.Exit(ExitTerminal)
 	}
 	cs.RequestHandlers[firstArgTypeStr] = f
@@ -432,7 +432,8 @@ func (cs *ClientServerImpl) WriteMessage(send []byte) error {
 	// library returns 'nil' anyway for SetWriteDeadline
 	// https://github.com/gorilla/websocket/blob/4201258b820c74ac8e6922fc9e6b52f71fe46f8d/conn.go#L761
 	if err := cs.conn.SetWriteDeadline(time.Now().Add(cs.RWTimeout)); err != nil {
-		seelog.Warnf("Unable to set write deadline for websocket connection: %v for %s", err, cs.URL)
+		logger.Warn(fmt.Sprintf("Unable to set write deadline for websocket connection: %v for %s",
+			err, cs.URL))
 	}
 
 	return cs.conn.WriteMessage(websocket.TextMessage, send)
@@ -469,20 +470,20 @@ func (cs *ClientServerImpl) ConsumeMessages(ctx context.Context) error {
 			case err == nil:
 				if messageType != websocket.TextMessage {
 					// maybe not fatal though, we'll try to process it anyways
-					seelog.Errorf("Unexpected messageType: %v", messageType)
+					logger.Error(fmt.Sprintf("Unexpected messageType: %v", messageType))
 				}
 
 				cs.handleMessage(message)
 
 			case permissibleCloseCode(err):
-				seelog.Debugf("Connection closed for a valid reason: %s", err)
+				logger.Debug(fmt.Sprintf("Connection closed for a valid reason: %s", err))
 				errChan <- io.EOF
 				return
 
 			default:
 				// Unexpected error occurred
-				seelog.Debugf("Error getting message from ws backend: error: [%v], messageType: [%v] ",
-					err, messageType)
+				logger.Debug(fmt.Sprintf("Error getting message from ws backend: error: [%v], messageType: [%v] ",
+					err, messageType))
 				errChan <- err
 				return
 			}
@@ -536,11 +537,11 @@ func (cs *ClientServerImpl) CreateRequestMessage(input interface{}) ([]byte, err
 func (cs *ClientServerImpl) handleMessage(data []byte) {
 	typedMessage, typeStr, err := DecodeData(data, cs.TypeDecoder)
 	if err != nil {
-		seelog.Warnf("Unable to handle message from backend: %v", err)
+		logger.Warn(fmt.Sprintf("Unable to handle message from backend: %v", err))
 		return
 	}
 
-	seelog.Debugf("Received message of type: %s", typeStr)
+	logger.Debug(fmt.Sprintf("Received message of type: %s", typeStr))
 
 	if cs.AnyRequestHandler != nil {
 		reflect.ValueOf(cs.AnyRequestHandler).Call([]reflect.Value{reflect.ValueOf(typedMessage)})
@@ -549,7 +550,7 @@ func (cs *ClientServerImpl) handleMessage(data []byte) {
 	if handler, ok := cs.RequestHandlers[typeStr]; ok {
 		reflect.ValueOf(handler).Call([]reflect.Value{reflect.ValueOf(typedMessage)})
 	} else {
-		seelog.Infof("No handler for message type: %s %s", typeStr, typedMessage)
+		logger.Info(fmt.Sprintf("No handler for message type: %s %s", typeStr, typedMessage))
 	}
 }
 

ecs-agent/wsclient/client_test.go

@@ -108,7 +108,7 @@ func getClientServer(url string) *ClientServerImpl {
 
 	return &ClientServerImpl{
 		URL: url,
-		cfg: &AgentConfig{
+		Cfg: &WSClientMinAgentConfig{
 			AcceptInsecureCert: true,
 			AWSRegion:          "us-east-1",
 			DockerEndpoint:     "unix://" + dockerEndpoint,