Restructure _BaseCallHandler et al. for interceptors
#1028
Merged
Conversation
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Motivation: The state management in `_BaseCallHandler` and its associated subclasses is a little handwavy and somewhat implicit. To support server interceptors we need a stronger idea of the state of the call. Modifications: - Refactor `_BaseCallHandler` to have an explicit state machine and hold an interceptor pipeline. This is the 'main' state machine. Each subclass also has its own down state machine holding state relating to the event observer and observer context. Most of the logic shared between the state machines is very similar, it may be beneficial to abstract some of this away in the future. - Add head and tail interceptors. - Wire through interceptors from the call handler factory (much like the client, generated server code will have its own interceptor factory which will pass interceptors to the call handler factory). Result: - Server interceptors (minus codegen)
glbrntt
added a commit
that referenced
this pull request
Nov 6, 2020
Motivation: The state management in `_BaseCallHandler` and its associated subclasses is a little handwavy and somewhat implicit. To support server interceptors we need a stronger idea of the state of the call. Modifications: - Refactor `_BaseCallHandler` to have an explicit state machine and hold an interceptor pipeline. This is the 'main' state machine. Each subclass also has its own down state machine holding state relating to the event observer and observer context. Most of the logic shared between the state machines is very similar, it may be beneficial to abstract some of this away in the future. - Add head and tail interceptors. - Wire through interceptors from the call handler factory (much like the client, generated server code will have its own interceptor factory which will pass interceptors to the call handler factory). Result: - Server interceptors (minus codegen)
glbrntt
added a commit
that referenced
this pull request
Nov 12, 2020
Motivation: The state management in `_BaseCallHandler` and its associated subclasses is a little handwavy and somewhat implicit. To support server interceptors we need a stronger idea of the state of the call. Modifications: - Refactor `_BaseCallHandler` to have an explicit state machine and hold an interceptor pipeline. This is the 'main' state machine. Each subclass also has its own down state machine holding state relating to the event observer and observer context. Most of the logic shared between the state machines is very similar, it may be beneficial to abstract some of this away in the future. - Add head and tail interceptors. - Wire through interceptors from the call handler factory (much like the client, generated server code will have its own interceptor factory which will pass interceptors to the call handler factory). Result: - Server interceptors (minus codegen)
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Add this suggestion to a batch that can be applied as a single commit.
This suggestion is invalid because no changes were made to the code.
Suggestions cannot be applied while the pull request is closed.
Suggestions cannot be applied while viewing a subset of changes.
Only one suggestion per line can be applied in a batch.
Add this suggestion to a batch that can be applied as a single commit.
Applying suggestions on deleted lines is not supported.
You must change the existing code in this line in order to create a valid suggestion.
Outdated suggestions cannot be applied.
This suggestion has been applied or marked resolved.
Suggestions cannot be applied from pending reviews.
Suggestions cannot be applied on multi-line comments.
Suggestions cannot be applied while the pull request is queued to merge.
Suggestion cannot be applied right now. Please check back later.
Motivation:
The state management in
_BaseCallHandlerand its associated subclassesis a little handwavy and somewhat implicit. To support server
interceptors we need a stronger idea of the state of the call.
Modifications:
_BaseCallHandlerto have an explicit state machine and holdan interceptor pipeline. This is the 'main' state machine. Each
subclass also has its own down state machine holding state relating to
the event observer and observer context. Most of the logic shared between
the state machines is very similar, it may be beneficial to abstract
some of this away in the future.
client, generated server code will have its own interceptor factory
which will pass interceptors to the call handler factory).
Result: