@@ -12,83 +12,86 @@ import (
1212func (t * translationContainerServer ) GenerateEncryptionKeys (stream services.TranslationContainer_GenerateEncryptionKeysServer ) error {
1313 clientName := ""
1414 // initially wait for a request from the other side with blank data to indicate who is talking to us
15- if initial , err := stream .Recv (); err == io .EOF {
15+ initial , err := stream .Recv ()
16+ if err == io .EOF {
1617 logging .LogDebug ("Client closed before ever sending anything, err is EOF" )
1718 return nil // the client closed before ever sending anything
18- } else if err != nil {
19+ }
20+ if err != nil {
1921 logging .LogError (err , "Client ran into an error before sending anything" )
2022 return err
21- } else {
22- clientName = initial .GetTranslationContainerName ()
23- if getMessageToSend , sendBackMessageResponse , err := t .addNewGenerateKeysClient (clientName ); err != nil {
24- logging .LogError (err , "Failed to add new channels to listen for connection" )
25- return err
26- } else {
27- logging .LogDebug ("Got translation container name from remote connection" , "name" , clientName )
28- for {
23+ }
24+ clientName = initial .GetTranslationContainerName ()
25+ getMessageToSend , sendBackMessageResponse , err := t .addNewGenerateKeysClient (clientName )
26+ if err != nil {
27+ logging .LogError (err , "Failed to add new channels to listen for connection" )
28+ return err
29+ }
30+ logging .LogDebug ("Got translation container name from remote connection" , "name" , clientName )
31+ for {
32+ select {
33+ case <- stream .Context ().Done ():
34+ logging .LogError (stream .Context ().Err (), fmt .Sprintf ("client disconnected: %s" , clientName ))
35+ t .SetGenerateKeysChannelExited (clientName )
36+ return errors .New (fmt .Sprintf ("client disconnected: %s" , clientName ))
37+ case msgToSend , ok := <- getMessageToSend :
38+ if ! ok {
39+ logging .LogError (nil , "got !ok from messageToSend, channel was closed" )
40+ t .SetGenerateKeysChannelExited (clientName )
41+ return nil
42+ }
43+ err = stream .Send (& msgToSend )
44+ if err != nil {
45+ logging .LogError (err , "Failed to send message through stream to translation container" )
46+ select {
47+ case sendBackMessageResponse <- services.TrGenerateEncryptionKeysMessageResponse {
48+ Success : false ,
49+ Error : err .Error (),
50+ TranslationContainerName : clientName ,
51+ }:
52+ case <- time .After (t .GetChannelTimeout ()):
53+ logging .LogError (errors .New ("timeout sending to channel" ), "gRPC stream connection needs to exit due to timeouts" )
54+ }
55+ t .SetGenerateKeysChannelExited (clientName )
56+ return err
57+ }
58+ resp , err := stream .Recv ()
59+ if err == io .EOF {
60+ // cleanup the connection channels first before returning
61+ logging .LogError (err , "connection closed in stream.Rev after sending message" )
62+ select {
63+ case sendBackMessageResponse <- services.TrGenerateEncryptionKeysMessageResponse {
64+ Success : false ,
65+ Error : err .Error (),
66+ TranslationContainerName : clientName ,
67+ }:
68+ case <- time .After (t .GetChannelTimeout ()):
69+ logging .LogError (errors .New ("timeout sending to channel" ), "gRPC stream connection needs to exit due to timeouts" )
70+ }
71+ t .SetGenerateKeysChannelExited (clientName )
72+ return nil
73+ }
74+ if err != nil {
75+ // cleanup the connection channels first before returning
76+ logging .LogError (err , "Failed to read from translation container" )
2977 select {
30- case <- stream .Context ().Done ():
31- logging .LogError (stream .Context ().Err (), fmt .Sprintf ("client disconnected: %s" , clientName ))
32- t .SetGenerateKeysChannelExited (clientName )
33- return errors .New (fmt .Sprintf ("client disconnected: %s" , clientName ))
34- case msgToSend , ok := <- getMessageToSend :
35- if ! ok {
36- logging .LogError (nil , "got !ok from messageToSend, channel was closed" )
37- t .SetGenerateKeysChannelExited (clientName )
38- return nil
39- } else {
40- if err = stream .Send (& msgToSend ); err != nil {
41- logging .LogError (err , "Failed to send message through stream to translation container" )
42- select {
43- case sendBackMessageResponse <- services.TrGenerateEncryptionKeysMessageResponse {
44- Success : false ,
45- Error : err .Error (),
46- TranslationContainerName : clientName ,
47- }:
48- case <- time .After (t .GetChannelTimeout ()):
49- logging .LogError (errors .New ("timeout sending to channel" ), "gRPC stream connection needs to exit due to timeouts" )
50- }
51- t .SetGenerateKeysChannelExited (clientName )
52- return err
53- } else if resp , err := stream .Recv (); err == io .EOF {
54- // cleanup the connection channels first before returning
55- logging .LogError (err , "connection closed in stream.Rev after sending message" )
56- select {
57- case sendBackMessageResponse <- services.TrGenerateEncryptionKeysMessageResponse {
58- Success : false ,
59- Error : err .Error (),
60- TranslationContainerName : clientName ,
61- }:
62- case <- time .After (t .GetChannelTimeout ()):
63- logging .LogError (errors .New ("timeout sending to channel" ), "gRPC stream connection needs to exit due to timeouts" )
64- }
65- t .SetGenerateKeysChannelExited (clientName )
66- return nil
67- } else if err != nil {
68- // cleanup the connection channels first before returning
69- logging .LogError (err , "Failed to read from translation container" )
70- select {
71- case sendBackMessageResponse <- services.TrGenerateEncryptionKeysMessageResponse {
72- Success : false ,
73- Error : err .Error (),
74- TranslationContainerName : clientName ,
75- }:
76- case <- time .After (t .GetChannelTimeout ()):
77- logging .LogError (errors .New ("timeout sending to channel" ), "gRPC stream connection needs to exit due to timeouts" )
78- }
79- t .SetGenerateKeysChannelExited (clientName )
80- return err
81- } else {
82- select {
83- case sendBackMessageResponse <- * resp :
84- case <- time .After (t .GetChannelTimeout ()):
85- logging .LogError (errors .New ("timeout sending to channel" ), "gRPC stream connection needs to exit due to timeouts" )
86- t .SetGenerateKeysChannelExited (clientName )
87- return err
88- }
89- }
90- }
78+ case sendBackMessageResponse <- services.TrGenerateEncryptionKeysMessageResponse {
79+ Success : false ,
80+ Error : err .Error (),
81+ TranslationContainerName : clientName ,
82+ }:
83+ case <- time .After (t .GetChannelTimeout ()):
84+ logging .LogError (errors .New ("timeout sending to channel" ), "gRPC stream connection needs to exit due to timeouts" )
9185 }
86+ t .SetGenerateKeysChannelExited (clientName )
87+ return err
88+ }
89+ select {
90+ case sendBackMessageResponse <- * resp :
91+ case <- time .After (t .GetChannelTimeout ()):
92+ logging .LogError (errors .New ("timeout sending to channel" ), "gRPC stream connection needs to exit due to timeouts" )
93+ t .SetGenerateKeysChannelExited (clientName )
94+ return err
9295 }
9396 }
9497 }
0 commit comments