225de2c936
ttrpc provides WithOnClose option for user and ttrpc will call the
callback function when connection is closed unexpectedly or the ttrpc
client's Close() method is called. containerd runtime plugin uses it
to handle cleanup the resources created by containerd shim.
But the ttrpc client's Close() is only trigger and the shim's cleanup
resource callback is called asynchronously, which might make part of
resources leaky. There is an example from containerd-runtime-v2 for
runc:
```happy
[Task.Delete goroutine] [cleanupCallback goroutine]
call ttrpc client.Close() -->
read bundle and call runc delete
delete bundle
```
If the cleanupCallback is called after deleting bundle, the callback
will fail to call runc delete. If there is any running processes, the
resource becomes leaky.
```unhappy
[Task.Delete goroutine] [cleanupCallback goroutine]
call ttrpc client.Close() -->
delete bundle
failed to read bundle and call runc delete
```
In order to avoid this, introduces the UserOnCloseWait to make sure that
the cleanupCallback has been called synchronously, like:
```
[Task.Delete goroutine] [cleanupCallback goroutine]
call ttrpc client.Close() -->
wait for callback
read bundle and call runc delete
<-- finish sync
delete bundle
```
Signed-off-by: Wei Fu <fuweid89@gmail.com>
71 lines
1.7 KiB
Go
71 lines
1.7 KiB
Go
/*
|
|
Copyright The containerd Authors.
|
|
|
|
Licensed under the Apache License, Version 2.0 (the "License");
|
|
you may not use this file except in compliance with the License.
|
|
You may obtain a copy of the License at
|
|
|
|
http://www.apache.org/licenses/LICENSE-2.0
|
|
|
|
Unless required by applicable law or agreed to in writing, software
|
|
distributed under the License is distributed on an "AS IS" BASIS,
|
|
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
See the License for the specific language governing permissions and
|
|
limitations under the License.
|
|
*/
|
|
|
|
package ttrpc
|
|
|
|
import (
|
|
"context"
|
|
"testing"
|
|
"time"
|
|
)
|
|
|
|
func TestUserOnCloseWait(t *testing.T) {
|
|
var (
|
|
ctx, cancel = context.WithDeadline(context.Background(), time.Now().Add(1*time.Minute))
|
|
server = mustServer(t)(NewServer())
|
|
testImpl = &testingServer{}
|
|
addr, listener = newTestListener(t)
|
|
)
|
|
|
|
defer cancel()
|
|
defer listener.Close()
|
|
|
|
registerTestingService(server, testImpl)
|
|
|
|
go server.Serve(ctx, listener)
|
|
defer server.Shutdown(ctx)
|
|
|
|
var (
|
|
dataCh = make(chan string)
|
|
client, cleanup = newTestClient(t, addr,
|
|
WithOnClose(func() {
|
|
dataCh <- time.Now().String()
|
|
}),
|
|
)
|
|
|
|
tp testPayload
|
|
tclient = newTestingClient(client)
|
|
)
|
|
|
|
if _, err := tclient.Test(ctx, &tp); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
cleanup()
|
|
|
|
fctx, fcancel := context.WithDeadline(ctx, time.Now().Add(1*time.Second))
|
|
defer fcancel()
|
|
if err := client.UserOnCloseWait(fctx); err == nil || err != context.DeadlineExceeded {
|
|
t.Fatalf("expected error %v, but got %v", context.DeadlineExceeded, err)
|
|
}
|
|
|
|
_ = <-dataCh
|
|
|
|
if err := client.UserOnCloseWait(ctx); err != nil {
|
|
t.Fatalf("expected error nil , but got %v", err)
|
|
}
|
|
}
|