signalmeow/web: use context logger, make SendHTTPRequest use context

sumnerevans · sumnerevans · commit 6b98c3f955d5 · 2024-01-07T13:23:59.000-07:00
Signed-off-by: Sumner Evans &lt;me@sumnerevans.com&gt;
diff --git a/commands.go b/commands.go
@@ -177,7 +177,7 @@ func fnSetDeviceName(ce *WrappedCommandEvent) {
 	}
 
 	name := strings.Join(ce.Args, " ")
-	err := ce.User.Client.UpdateDeviceName(name)
+	err := ce.User.Client.UpdateDeviceName(ce.Ctx, name)
 	if err != nil {
 		ce.Reply("Error setting device name: %v", err)
 		return
diff --git a/pkg/signalmeow/attachments.go b/pkg/signalmeow/attachments.go
@@ -139,7 +139,7 @@ func (cli *Client) UploadAttachment(ctx context.Context, body []byte) (*signalpb
 	attributesPath := "/v3/attachments/form/upload"
 	username, password := cli.Store.BasicAuthCreds()
 	opts := &web.HTTPReqOpt{Username: &username, Password: &password}
-	resp, err := web.SendHTTPRequest(http.MethodGet, attributesPath, opts)
+	resp, err := web.SendHTTPRequest(ctx, http.MethodGet, attributesPath, opts)
 	if err != nil {
 		log.Err(err).Msg("Error sending request fetching upload attributes")
 		return nil, err
@@ -152,7 +152,7 @@ func (cli *Client) UploadAttachment(ctx context.Context, body []byte) (*signalpb
 	}
 
 	// Allocate attachment on CDN
-	resp, err = web.SendHTTPRequest(http.MethodPost, "", &web.HTTPReqOpt{
+	resp, err = web.SendHTTPRequest(ctx, http.MethodPost, "", &web.HTTPReqOpt{
 		OverrideURL: uploadAttributes.SignedUploadLocation,
 		ContentType: web.ContentTypeOctetStream,
 		Headers:     uploadAttributes.Headers,
@@ -169,7 +169,7 @@ func (cli *Client) UploadAttachment(ctx context.Context, body []byte) (*signalpb
 	}
 
 	// Upload attachment to CDN
-	resp, err = web.SendHTTPRequest(http.MethodPut, "", &web.HTTPReqOpt{
+	resp, err = web.SendHTTPRequest(ctx, http.MethodPut, "", &web.HTTPReqOpt{
 		OverrideURL: resp.Header.Get("Location"),
 		Body:        encryptedWithMAC,
 		ContentType: web.ContentTypeOctetStream,
diff --git a/pkg/signalmeow/devicename.go b/pkg/signalmeow/devicename.go
@@ -17,6 +17,7 @@
 package signalmeow
 
 import (
+	"context"
 	"crypto/aes"
 	"crypto/cipher"
 	"crypto/hmac"
@@ -43,27 +44,27 @@ func aes256CTR(key, iv, dst, source []byte) {
 	cipher.NewCTR(block, iv).XORKeyStream(dst, source)
 }
 
-func (cli *Client) UpdateDeviceName(name string) error {
+func (cli *Client) UpdateDeviceName(ctx context.Context, name string) error {
 	encryptedName, err := EncryptDeviceName(name, cli.Store.ACIIdentityKeyPair.GetPublicKey())
 	if err != nil {
 		return fmt.Errorf("failed to encrypt device name: %w", err)
 	}
-	err = cli.updateDeviceName(encryptedName)
+	err = cli.updateDeviceName(ctx, encryptedName)
 	if err != nil {
 		return fmt.Errorf("failed to update device name: %w", err)
 	}
 	return nil
 }
 
-func (cli *Client) updateDeviceName(encryptedName []byte) error {
+func (cli *Client) updateDeviceName(ctx context.Context, encryptedName []byte) error {
 	reqData, err := json.Marshal(map[string]any{
 		"deviceName": encryptedName,
 	})
 	if err != nil {
 		return fmt.Errorf("failed to marshal device name update request: %w", err)
 	}
 	username, password := cli.Store.BasicAuthCreds()
-	resp, err := web.SendHTTPRequest(http.MethodPut, "/v1/accounts/name", &web.HTTPReqOpt{
+	resp, err := web.SendHTTPRequest(ctx, http.MethodPut, "/v1/accounts/name", &web.HTTPReqOpt{
 		Body:     reqData,
 		Username: &username,
 		Password: &password,
diff --git a/pkg/signalmeow/groups.go b/pkg/signalmeow/groups.go
@@ -379,7 +379,7 @@ func (cli *Client) fetchGroupByID(ctx context.Context, gid types.GroupIdentifier
 		ContentType: web.ContentTypeProtobuf,
 		Host:        web.StorageHostname,
 	}
-	response, err := web.SendHTTPRequest(http.MethodGet, "/v1/groups", opts)
+	response, err := web.SendHTTPRequest(ctx, http.MethodGet, "/v1/groups", opts)
 	if err != nil {
 		zlog.Err(err).Msg("RetrieveGroupById SendHTTPRequest error")
 		return nil, err
@@ -425,7 +425,7 @@ func (cli *Client) DownloadGroupAvatar(ctx context.Context, group *Group) ([]byt
 		Username: &username,
 		Password: &password,
 	}
-	resp, err := web.SendHTTPRequest(http.MethodGet, group.AvatarPath, opts)
+	resp, err := web.SendHTTPRequest(ctx, http.MethodGet, group.AvatarPath, opts)
 	if err != nil {
 		return nil, fmt.Errorf("failed to send request: %w", err)
 	}
diff --git a/pkg/signalmeow/keys.go b/pkg/signalmeow/keys.go
@@ -86,7 +86,7 @@ func (cli *Client) GenerateAndRegisterPreKeys(ctx context.Context, uuidKind type
 		preKeyUsername = cli.Store.ACI.String()
 	}
 	preKeyUsername = fmt.Sprintf("%s.%d", preKeyUsername, cli.Store.DeviceID)
-	err = RegisterPreKeys(&generatedPreKeys, uuidKind, preKeyUsername, cli.Store.Password)
+	err = RegisterPreKeys(ctx, &generatedPreKeys, uuidKind, preKeyUsername, cli.Store.Password)
 	if err != nil {
 		zlog.Err(err).Msg("RegisterPreKeys error")
 		return err
@@ -228,7 +228,8 @@ func KyberPreKeyToJSON(kyberPreKey *libsignalgo.KyberPreKeyRecord) map[string]in
 	return kyberPreKeyJson
 }
 
-func RegisterPreKeys(generatedPreKeys *GeneratedPreKeys, uuidKind types.UUIDKind, username string, password string) error {
+func RegisterPreKeys(ctx context.Context, generatedPreKeys *GeneratedPreKeys, uuidKind types.UUIDKind, username string, password string) error {
+	log := zerolog.Ctx(ctx).With().Str("action", "register prekeys").Logger()
 	// Convert generated prekeys to JSON
 	preKeysJson := []map[string]interface{}{}
 	kyberPreKeysJson := []map[string]interface{}{}
@@ -252,22 +253,20 @@ func RegisterPreKeys(generatedPreKeys *GeneratedPreKeys, uuidKind types.UUIDKind
 	keysPath := "/v2/keys?identity=" + string(uuidKind)
 	jsonBytes, err := json.Marshal(register_json)
 	if err != nil {
-		zlog.Err(err).Msg("Error marshalling register JSON")
+		log.Err(err).Msg("Error marshalling register JSON")
 		return err
 	}
 	opts := &web.HTTPReqOpt{Body: jsonBytes, Username: &username, Password: &password}
-	resp, err := web.SendHTTPRequest(http.MethodPut, keysPath, opts)
+	resp, err := web.SendHTTPRequest(ctx, http.MethodPut, keysPath, opts)
 	if err != nil {
-		zlog.Err(err).Msg("Error sending request")
+		log.Err(err).Msg("Error sending request")
 		return err
 	}
+	defer resp.Body.Close()
 	// status code not 2xx
 	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
-		err := fmt.Errorf("Error registering prekeys: %v", resp.Status)
-		zlog.Err(err).Msg("Error registering prekeys")
-		return err
+		return fmt.Errorf("error registering prekeys: %v", resp.Status)
 	}
-	defer resp.Body.Close()
 	return err
 }
 
@@ -306,7 +305,7 @@ func (cli *Client) FetchAndProcessPreKey(ctx context.Context, theirUUID uuid.UUI
 	}
 	path := "/v2/keys/" + theirUUID.String() + deviceIDPath + "?pq=true"
 	username, password := cli.Store.BasicAuthCreds()
-	resp, err := web.SendHTTPRequest(http.MethodGet, path, &web.HTTPReqOpt{Username: &username, Password: &password})
+	resp, err := web.SendHTTPRequest(ctx, http.MethodGet, path, &web.HTTPReqOpt{Username: &username, Password: &password})
 	if err != nil {
 		zlog.Err(err).Msg("Error sending request")
 		return err
diff --git a/pkg/signalmeow/misc.go b/pkg/signalmeow/misc.go
@@ -22,7 +22,6 @@ import (
 	"github.com/rs/zerolog"
 
 	"go.mau.fi/mautrix-signal/pkg/libsignalgo"
-	"go.mau.fi/mautrix-signal/pkg/signalmeow/web"
 )
 
 // Deprecated: global loggers are bad
@@ -31,7 +30,6 @@ var zlog zerolog.Logger = zerolog.New(zerolog.ConsoleWriter{}).With().Timestamp(
 func SetLogger(l zerolog.Logger) {
 	zlog = l
 	setupFFILogging()
-	web.SetLogger(l.With().Str("component", "signalmeow/web").Logger())
 }
 
 type FFILogger struct{}
diff --git a/pkg/signalmeow/profile.go b/pkg/signalmeow/profile.go
@@ -220,7 +220,7 @@ func (cli *Client) fetchProfileByID(ctx context.Context, signalID uuid.UUID) (*P
 	}
 	zlog.Trace().Msg("Got profile response")
 	if *resp.Status < 200 || *resp.Status >= 300 {
-		err := errors.New(fmt.Sprintf("%v (unsuccessful status code)", *resp.Status))
+		err := fmt.Errorf("%v (unsuccessful status code)", *resp.Status)
 		zlog.Err(err).Msg("profile response error")
 		return nil, err
 	}
@@ -237,7 +237,7 @@ func (cli *Client) fetchProfileByID(ctx context.Context, signalID uuid.UUID) (*P
 			zlog.Err(err).Msg("error decrypting profile name")
 		}
 		// TODO store first and last name separately instead of removing the separator
-		profile.Name = strings.Replace(profile.Name, "\x00", " ", -1)
+		profile.Name = strings.ReplaceAll(profile.Name, "\x00", " ")
 	}
 	if len(profileResponse.About) > 0 {
 		profile.About, err = decryptString(profileKey, profileResponse.About)
@@ -257,14 +257,14 @@ func (cli *Client) fetchProfileByID(ctx context.Context, signalID uuid.UUID) (*P
 	return &profile, nil
 }
 
-func (cli *Client) DownloadUserAvatar(avatarPath string, profileKey *libsignalgo.ProfileKey) ([]byte, error) {
+func (cli *Client) DownloadUserAvatar(ctx context.Context, avatarPath string, profileKey *libsignalgo.ProfileKey) ([]byte, error) {
 	username, password := cli.Store.BasicAuthCreds()
 	opts := &web.HTTPReqOpt{
 		Host:     web.CDN1Hostname,
 		Username: &username,
 		Password: &password,
 	}
-	resp, err := web.SendHTTPRequest(http.MethodGet, avatarPath, opts)
+	resp, err := web.SendHTTPRequest(ctx, http.MethodGet, avatarPath, opts)
 	if err != nil {
 		return nil, fmt.Errorf("failed to send request: %w", err)
 	}
diff --git a/pkg/signalmeow/provisioning.go b/pkg/signalmeow/provisioning.go
@@ -29,6 +29,7 @@ import (
 	"time"
 
 	"github.com/google/uuid"
+	"github.com/rs/zerolog"
 	"google.golang.org/protobuf/proto"
 	"nhooyr.io/websocket"
 
@@ -249,14 +250,15 @@ func PerformProvisioning(incomingCtx context.Context, deviceStore store.DeviceSt
 
 // Returns the provisioningUrl and an error
 func startProvisioning(ctx context.Context, ws *websocket.Conn, provisioningCipher *ProvisioningCipher) (string, error) {
+	log := zerolog.Ctx(ctx).With().Str("action", "start provisioning").Logger()
 	pubKey := provisioningCipher.GetPublicKey()
 
 	provisioningUrl := ""
 
 	msg := &signalpb.WebSocketMessage{}
 	err := wspb.Read(ctx, ws, msg)
 	if err != nil {
-		zlog.Err(err).Msg("error reading websocket message")
+		log.Err(err).Msg("error reading websocket message")
 		return "", err
 	}
 
@@ -280,22 +282,23 @@ func startProvisioning(ctx context.Context, ws *websocket.Conn, provisioningCiph
 		provisioningUrl = "sgnl://linkdevice?uuid=" + uuid + "&pub_key=" + pubKey
 
 		// Create and send response
-		response := web.CreateWSResponse(*msg.Request.Id, 200)
+		response := web.CreateWSResponse(ctx, *msg.Request.Id, 200)
 		err = wspb.Write(ctx, ws, response)
 		if err != nil {
-			zlog.Err(err).Msg("error writing websocket message")
+			log.Err(err).Msg("error writing websocket message")
 			return "", err
 		}
 	}
 	return provisioningUrl, nil
 }
 
 func continueProvisioning(ctx context.Context, ws *websocket.Conn, provisioningCipher *ProvisioningCipher) (*signalpb.ProvisionMessage, error) {
+	log := zerolog.Ctx(ctx).With().Str("action", "continue provisioning").Logger()
 	envelope := &signalpb.ProvisionEnvelope{}
 	msg := &signalpb.WebSocketMessage{}
 	err := wspb.Read(ctx, ws, msg)
 	if err != nil {
-		zlog.Err(err).Msg("error reading websocket message")
+		log.Err(err).Msg("error reading websocket message")
 		return nil, err
 	}
 
@@ -309,15 +312,15 @@ func continueProvisioning(ctx context.Context, ws *websocket.Conn, provisioningC
 			return nil, err
 		}
 
-		response := web.CreateWSResponse(*msg.Request.Id, 200)
+		response := web.CreateWSResponse(ctx, *msg.Request.Id, 200)
 		err = wspb.Write(ctx, ws, response)
 		if err != nil {
-			zlog.Err(err).Msg("error writing websocket message")
+			log.Err(err).Msg("error writing websocket message")
 			return nil, err
 		}
 	} else {
 		err = fmt.Errorf("invalid provisioning message, type: %v, verb: %v, path: %v", *msg.Type, *msg.Request.Verb, *msg.Request.Path)
-		zlog.Err(err).Msg("problem reading websocket message")
+		log.Err(err).Msg("problem reading websocket message")
 		return nil, err
 	}
 	provisioningMessage, err := provisioningCipher.Decrypt(envelope)
diff --git a/pkg/signalmeow/sending.go b/pkg/signalmeow/sending.go
@@ -60,7 +60,7 @@ func (cli *Client) senderCertificate(ctx context.Context) (*libsignalgo.SenderCe
 
 	username, password := cli.Store.BasicAuthCreds()
 	opts := &web.HTTPReqOpt{Username: &username, Password: &password}
-	resp, err := web.SendHTTPRequest(http.MethodGet, "/v1/certificate/delivery", opts)
+	resp, err := web.SendHTTPRequest(ctx, http.MethodGet, "/v1/certificate/delivery", opts)
 	if err != nil {
 		return nil, err
 	}
@@ -121,7 +121,7 @@ func addPadding(version uint32, contents []byte) ([]byte, error) {
 
 		err := padBlock(&buffer, messageLength)
 		if err != nil {
-			return nil, errors.New(fmt.Sprintf("Invalid message padding: %v", err))
+			return nil, fmt.Errorf("Invalid message padding: %w", err)
 		}
 		return buffer, nil
 	}
diff --git a/pkg/signalmeow/web/signalwebsocket.go b/pkg/signalmeow/web/signalwebsocket.go
@@ -219,14 +219,14 @@ func (s *SignalWebsocket) connectLoop(
 					// Unexpected status code
 					s.statusChannel <- SignalWebsocketConnectionStatus{
 						Event: SignalWebsocketConnectionEventError,
-						Err:   fmt.Errorf("Bad status opening websocket: %v", resp.Status),
+						Err:   fmt.Errorf("bad status opening websocket: %v", resp.Status),
 					}
 					return // NOT RETRYING, KILLING THE CONNECTION LOOP
 				} else {
 					// Something is very wrong
 					s.statusChannel <- SignalWebsocketConnectionStatus{
 						Event: SignalWebsocketConnectionEventError,
-						Err:   fmt.Errorf("Unexpected error opening websocket: %v", resp.Status),
+						Err:   fmt.Errorf("unexpected error opening websocket: %v", resp.Status),
 					}
 				}
 				// Retry the connection
@@ -385,10 +385,10 @@ func readLoop(
 			return fmt.Errorf("error reading message: %w", err)
 		}
 		if msg.Type == nil {
-			return errors.New("Received message with no type")
+			return errors.New("received message with no type")
 		} else if *msg.Type == signalpb.WebSocketMessage_REQUEST {
 			if msg.Request == nil {
-				return errors.New("Received request message with no request")
+				return errors.New("received request message with no request")
 			}
 			log.Debug().
 				Uint64("request_id", *msg.Request.Id).
@@ -421,9 +421,9 @@ func readLoop(
 				Msg("Deleted response channel for ID")
 			close(responseChannel)
 		} else if *msg.Type == signalpb.WebSocketMessage_UNKNOWN {
-			return fmt.Errorf("Received message with unknown type: %v", *msg.Type)
+			return fmt.Errorf("received message with unknown type: %v", *msg.Type)
 		} else {
-			return fmt.Errorf("Received message with actually unknown type: %v", *msg.Type)
+			return fmt.Errorf("received message with actually unknown type: %v", *msg.Type)
 		}
 	}
 }
@@ -498,7 +498,7 @@ func writeLoop(
 					return fmt.Errorf("error writing request message: %w", err)
 				}
 			} else if request.RequestMessage != nil && request.ResponseMessage != nil {
-				message := CreateWSResponse(*request.RequestMessage.Id, request.ResponseMessage.Status)
+				message := CreateWSResponse(ctx, *request.RequestMessage.Id, request.ResponseMessage.Status)
 				log.Debug().
 					Uint64("request_id", *request.RequestMessage.Id).
 					Int("response_status", request.ResponseMessage.Status).
@@ -508,7 +508,7 @@ func writeLoop(
 					return fmt.Errorf("error writing response message: %w", err)
 				}
 			} else {
-				return fmt.Errorf("Invalid request: %+v", request)
+				return fmt.Errorf("invalid request: %+v", request)
 			}
 		}
 	}
@@ -576,10 +576,10 @@ func OpenWebsocket(ctx context.Context, path string) (*websocket.Conn, *http.Res
 	return ws, resp, err
 }
 
-func CreateWSResponse(id uint64, status int) *signalpb.WebSocketMessage {
+func CreateWSResponse(ctx context.Context, id uint64, status int) *signalpb.WebSocketMessage {
 	if status != 200 && status != 400 {
 		// TODO support more responses to Signal? Are there more?
-		zlog.Fatal().Int("status", status).Msg("Error creating response. Non 200/400 not supported yet.")
+		zerolog.Ctx(ctx).Fatal().Int("status", status).Msg("Error creating response. Non 200/400 not supported yet.")
 		return nil
 	}
 	msg_type := signalpb.WebSocketMessage_RESPONSE
diff --git a/pkg/signalmeow/web/web.go b/pkg/signalmeow/web/web.go
diff --git a/provisioning.go b/provisioning.go
diff --git a/puppet.go b/puppet.go

Original file line number	Diff line number	Diff line change
`@@ -177,7 +177,7 @@ func fnSetDeviceName(ce *WrappedCommandEvent) {`
`177`	`177`	`}`
`178`	`178`
`179`	`179`	`name := strings.Join(ce.Args, " ")`
`180`		`- err := ce.User.Client.UpdateDeviceName(name)`
	`180`	`+ err := ce.User.Client.UpdateDeviceName(ce.Ctx, name)`
`181`	`181`	`if err != nil {`
`182`	`182`	`ce.Reply("Error setting device name: %v", err)`
`183`	`183`	`return`
Original file line number	Diff line number	Diff line change
`@@ -379,7 +379,7 @@ func (cli *Client) fetchGroupByID(ctx context.Context, gid types.GroupIdentifier`
`379`	`379`	`ContentType: web.ContentTypeProtobuf,`
`380`	`380`	`Host: web.StorageHostname,`
`381`	`381`	`}`
`382`		`- response, err := web.SendHTTPRequest(http.MethodGet, "/v1/groups", opts)`
	`382`	`+ response, err := web.SendHTTPRequest(ctx, http.MethodGet, "/v1/groups", opts)`
`383`	`383`	`if err != nil {`
`384`	`384`	`zlog.Err(err).Msg("RetrieveGroupById SendHTTPRequest error")`
`385`	`385`	`return nil, err`
`@@ -425,7 +425,7 @@ func (cli Client) DownloadGroupAvatar(ctx context.Context, group Group) ([]byt`
`425`	`425`	`Username: &username,`
`426`	`426`	`Password: &password,`
`427`	`427`	`}`
`428`		`- resp, err := web.SendHTTPRequest(http.MethodGet, group.AvatarPath, opts)`
	`428`	`+ resp, err := web.SendHTTPRequest(ctx, http.MethodGet, group.AvatarPath, opts)`
`429`	`429`	`if err != nil {`
`430`	`430`	`return nil, fmt.Errorf("failed to send request: %w", err)`
`431`	`431`	`}`
Original file line number	Diff line number	Diff line change
`@@ -22,7 +22,6 @@ import (`
`22`	`22`	`"github.com/rs/zerolog"`
`23`	`23`
`24`	`24`	`"go.mau.fi/mautrix-signal/pkg/libsignalgo"`
`25`		`- "go.mau.fi/mautrix-signal/pkg/signalmeow/web"`
`26`	`25`	`)`
`27`	`26`
`28`	`27`	`// Deprecated: global loggers are bad`
`@@ -31,7 +30,6 @@ var zlog zerolog.Logger = zerolog.New(zerolog.ConsoleWriter{}).With().Timestamp(`
`31`	`30`	`func SetLogger(l zerolog.Logger) {`
`32`	`31`	`zlog = l`
`33`	`32`	`setupFFILogging()`
`34`		`- web.SetLogger(l.With().Str("component", "signalmeow/web").Logger())`
`35`	`33`	`}`
`36`	`34`
`37`	`35`	`type FFILogger struct{}`
Original file line number	Diff line number	Diff line change
`@@ -220,7 +220,7 @@ func (cli Client) fetchProfileByID(ctx context.Context, signalID uuid.UUID) (P`
`220`	`220`	`}`
`221`	`221`	`zlog.Trace().Msg("Got profile response")`
`222`	`222`	`if resp.Status < 200 \|\| resp.Status >= 300 {`
`223`		`- err := errors.New(fmt.Sprintf("%v (unsuccessful status code)", *resp.Status))`
	`223`	`+ err := fmt.Errorf("%v (unsuccessful status code)", *resp.Status)`
`224`	`224`	`zlog.Err(err).Msg("profile response error")`
`225`	`225`	`return nil, err`
`226`	`226`	`}`
`@@ -237,7 +237,7 @@ func (cli Client) fetchProfileByID(ctx context.Context, signalID uuid.UUID) (P`
`237`	`237`	`zlog.Err(err).Msg("error decrypting profile name")`
`238`	`238`	`}`
`239`	`239`	`// TODO store first and last name separately instead of removing the separator`
`240`		`- profile.Name = strings.Replace(profile.Name, "\x00", " ", -1)`
	`240`	`+ profile.Name = strings.ReplaceAll(profile.Name, "\x00", " ")`
`241`	`241`	`}`
`242`	`242`	`if len(profileResponse.About) > 0 {`
`243`	`243`	`profile.About, err = decryptString(profileKey, profileResponse.About)`
`@@ -257,14 +257,14 @@ func (cli Client) fetchProfileByID(ctx context.Context, signalID uuid.UUID) (P`
`257`	`257`	`return &profile, nil`
`258`	`258`	`}`
`259`	`259`
`260`		`-func (cli Client) DownloadUserAvatar(avatarPath string, profileKey libsignalgo.ProfileKey) ([]byte, error) {`
	`260`	`+func (cli Client) DownloadUserAvatar(ctx context.Context, avatarPath string, profileKey libsignalgo.ProfileKey) ([]byte, error) {`
`261`	`261`	`username, password := cli.Store.BasicAuthCreds()`
`262`	`262`	`opts := &web.HTTPReqOpt{`
`263`	`263`	`Host: web.CDN1Hostname,`
`264`	`264`	`Username: &username,`
`265`	`265`	`Password: &password,`
`266`	`266`	`}`
`267`		`- resp, err := web.SendHTTPRequest(http.MethodGet, avatarPath, opts)`
	`267`	`+ resp, err := web.SendHTTPRequest(ctx, http.MethodGet, avatarPath, opts)`
`268`	`268`	`if err != nil {`
`269`	`269`	`return nil, fmt.Errorf("failed to send request: %w", err)`
`270`	`270`	`}`
Original file line number	Diff line number	Diff line change
`@@ -60,7 +60,7 @@ func (cli Client) senderCertificate(ctx context.Context) (libsignalgo.SenderCe`
`60`	`60`
`61`	`61`	`username, password := cli.Store.BasicAuthCreds()`
`62`	`62`	`opts := &web.HTTPReqOpt{Username: &username, Password: &password}`
`63`		`- resp, err := web.SendHTTPRequest(http.MethodGet, "/v1/certificate/delivery", opts)`
	`63`	`+ resp, err := web.SendHTTPRequest(ctx, http.MethodGet, "/v1/certificate/delivery", opts)`
`64`	`64`	`if err != nil {`
`65`	`65`	`return nil, err`
`66`	`66`	`}`
`@@ -121,7 +121,7 @@ func addPadding(version uint32, contents []byte) ([]byte, error) {`
`121`	`121`
`122`	`122`	`err := padBlock(&buffer, messageLength)`
`123`	`123`	`if err != nil {`
`124`		`- return nil, errors.New(fmt.Sprintf("Invalid message padding: %v", err))`
	`124`	`+ return nil, fmt.Errorf("Invalid message padding: %w", err)`
`125`	`125`	`}`
`126`	`126`	`return buffer, nil`
`127`	`127`	`}`
Original file line number	Diff line number	Diff line change
`@@ -219,14 +219,14 @@ func (s *SignalWebsocket) connectLoop(`
`219`	`219`	`// Unexpected status code`
`220`	`220`	`s.statusChannel <- SignalWebsocketConnectionStatus{`
`221`	`221`	`Event: SignalWebsocketConnectionEventError,`
`222`		`- Err: fmt.Errorf("Bad status opening websocket: %v", resp.Status),`
	`222`	`+ Err: fmt.Errorf("bad status opening websocket: %v", resp.Status),`
`223`	`223`	`}`
`224`	`224`	`return // NOT RETRYING, KILLING THE CONNECTION LOOP`
`225`	`225`	`} else {`
`226`	`226`	`// Something is very wrong`
`227`	`227`	`s.statusChannel <- SignalWebsocketConnectionStatus{`
`228`	`228`	`Event: SignalWebsocketConnectionEventError,`
`229`		`- Err: fmt.Errorf("Unexpected error opening websocket: %v", resp.Status),`
	`229`	`+ Err: fmt.Errorf("unexpected error opening websocket: %v", resp.Status),`
`230`	`230`	`}`
`231`	`231`	`}`
`232`	`232`	`// Retry the connection`
`@@ -385,10 +385,10 @@ func readLoop(`
`385`	`385`	`return fmt.Errorf("error reading message: %w", err)`
`386`	`386`	`}`
`387`	`387`	`if msg.Type == nil {`
`388`		`- return errors.New("Received message with no type")`
	`388`	`+ return errors.New("received message with no type")`
`389`	`389`	`} else if *msg.Type == signalpb.WebSocketMessage_REQUEST {`
`390`	`390`	`if msg.Request == nil {`
`391`		`- return errors.New("Received request message with no request")`
	`391`	`+ return errors.New("received request message with no request")`
`392`	`392`	`}`
`393`	`393`	`log.Debug().`
`394`	`394`	`Uint64("request_id", *msg.Request.Id).`
`@@ -421,9 +421,9 @@ func readLoop(`
`421`	`421`	`Msg("Deleted response channel for ID")`
`422`	`422`	`close(responseChannel)`
`423`	`423`	`} else if *msg.Type == signalpb.WebSocketMessage_UNKNOWN {`
`424`		`- return fmt.Errorf("Received message with unknown type: %v", *msg.Type)`
	`424`	`+ return fmt.Errorf("received message with unknown type: %v", *msg.Type)`
`425`	`425`	`} else {`
`426`		`- return fmt.Errorf("Received message with actually unknown type: %v", *msg.Type)`
	`426`	`+ return fmt.Errorf("received message with actually unknown type: %v", *msg.Type)`
`427`	`427`	`}`
`428`	`428`	`}`
`429`	`429`	`}`
`@@ -498,7 +498,7 @@ func writeLoop(`
`498`	`498`	`return fmt.Errorf("error writing request message: %w", err)`
`499`	`499`	`}`
`500`	`500`	`} else if request.RequestMessage != nil && request.ResponseMessage != nil {`
`501`		`- message := CreateWSResponse(*request.RequestMessage.Id, request.ResponseMessage.Status)`
	`501`	`+ message := CreateWSResponse(ctx, *request.RequestMessage.Id, request.ResponseMessage.Status)`
`502`	`502`	`log.Debug().`
`503`	`503`	`Uint64("request_id", *request.RequestMessage.Id).`
`504`	`504`	`Int("response_status", request.ResponseMessage.Status).`
`@@ -508,7 +508,7 @@ func writeLoop(`
`508`	`508`	`return fmt.Errorf("error writing response message: %w", err)`
`509`	`509`	`}`
`510`	`510`	`} else {`
`511`		`- return fmt.Errorf("Invalid request: %+v", request)`
	`511`	`+ return fmt.Errorf("invalid request: %+v", request)`
`512`	`512`	`}`
`513`	`513`	`}`
`514`	`514`	`}`
`@@ -576,10 +576,10 @@ func OpenWebsocket(ctx context.Context, path string) (websocket.Conn, http.Res`
`576`	`576`	`return ws, resp, err`
`577`	`577`	`}`
`578`	`578`
`579`		`-func CreateWSResponse(id uint64, status int) *signalpb.WebSocketMessage {`
	`579`	`+func CreateWSResponse(ctx context.Context, id uint64, status int) *signalpb.WebSocketMessage {`
`580`	`580`	`if status != 200 && status != 400 {`
`581`	`581`	`// TODO support more responses to Signal? Are there more?`
`582`		`- zlog.Fatal().Int("status", status).Msg("Error creating response. Non 200/400 not supported yet.")`
	`582`	`+ zerolog.Ctx(ctx).Fatal().Int("status", status).Msg("Error creating response. Non 200/400 not supported yet.")`
`583`	`583`	`return nil`
`584`	`584`	`}`
`585`	`585`	`msg_type := signalpb.WebSocketMessage_RESPONSE`