go.temporal.io/server/chasm/registry.go
389 LOC · 213 covered · 176 uncovered · 94 ranges · 4478 concepts · 65 introducers · 1704 tests
File neighbourhood
The centred file is linked to every concept that introduces one of its ranges, every test that runs code from the file, and the gray connector concepts standing between those tests and the file's own introducer concepts. Undirected links join concepts to every file where they introduce source and concepts to the tests they introduce; arrows show specialization between the displayed concepts and bridge only concepts omitted from this view. Concept colors match the source ranges below; connector concepts have no source color and are shown in gray.
Focused file, its introducer and connector concepts, their introduced files, and tests that run code from the file
In the embedded map, ordinary wheel input scrolls the page; use the visible controls to zoom and drag to pan. Open the full-screen map for canvas navigation: wheel pans, Ctrl/Command plus wheel zooms, and arrow keys pan when this region is focused. On touch screens, open the full-screen map to pan or pinch. If JavaScript or WebGL is unavailable, use the related-file, concept, and source links on this page.
Graph controls are ready.
Interactive rendering requires JavaScript and WebGL. Use the related-file, concept, and source links on this page while the interactive map is unavailable.
1
package chasm
2
3
import (
4
"errors"
5
"fmt"
6
"maps"
7
"reflect"
8
"regexp"
9
"strings"
10
11
"github.com/nexus-rpc/sdk-go/nexus"
12
"go.temporal.io/server/common/log"
13
"google.golang.org/grpc"
14
)
15
16
var (
17
// This is golang type identifier regex.
18
nameValidator = regexp.MustCompile(`^[A-Za-z_][A-Za-z0-9_]*$`)
19
)
20
21
type (
22
Registry struct {
23
libraries map[string]Library // library name -> library
24
25
// rc stands for RegistrableComponent.
26
rcByFqn map[string]*RegistrableComponent // fully qualified type name -> component
27
rcByID map[uint32]*RegistrableComponent // component type ID -> component
28
rcByGoType map[reflect.Type]*RegistrableComponent // component go type -> component
29
// rcContextValues is aggregated context values from all components,
30
// used for easy lookup when Context.Value(key) is called.
31
// Registration process will check for key conflicts and return error if same key is registered by multiple components.
32
rcContextValues map[any]valueWithFqn
33
34
// rt stands for RegistrableTask.
35
rtByFqn map[string]*RegistrableTask // fully qualified type name -> task
36
rtByID map[uint32]*RegistrableTask // task type ID -> task
37
rtByGoType map[reflect.Type]*RegistrableTask // task go type -> task
38
39
nexusServices map[string]*nexus.Service // service name -> nexus service
40
NexusEndpointProcessor *NexusEndpointProcessor
41
42
logger log.Logger
43
}
44
)
45
46
// valueWithFqn is a wrapper struct that associates a value with
47
// the fully qualified name (FQN) of the component that registered it.
48
type valueWithFqn struct {
49
v any
50
fqn string
51
}
52
54
>
return &Registry{
55
>
libraries: make(map[string]Library),
56
>
rcByFqn: make(map[string]*RegistrableComponent),
57
>
rcByID: make(map[uint32]*RegistrableComponent),
58
>
rcByGoType: make(map[reflect.Type]*RegistrableComponent),
59
>
rtByFqn: make(map[string]*RegistrableTask),
60
>
rtByID: make(map[uint32]*RegistrableTask),
61
>
rtByGoType: make(map[reflect.Type]*RegistrableTask),
62
>
rcContextValues: make(map[any]valueWithFqn),
63
>
nexusServices: make(map[string]*nexus.Service),
64
>
NexusEndpointProcessor: NewNexusEndpointProcessor(),
65
>
logger: logger,
66
>
}
67
>
}
68
70
>
if err := r.validateName(lib.Name()); err != nil {
72
>
}
74
return fmt.Errorf("library %s is already registered", lib.Name())
75
}
77
>
78
>
for _, c := range lib.Components() {
81
>
}
82
}
86
>
}
87
}
88
92
>
}
93
}
94
97
return err
98
}
99
}
100
102
}
103
104
// RegisterServices registers all gRPC services from all registered libraries.
106
>
for _, lib := range r.libraries {
107
>
lib.RegisterServices(server)
108
>
}
109
}
110
111
// ComponentFqnByID converts component type ID to fully qualified component type name.
112
// This method should only be used by CHASM framework internal code,
113
// NOT CHASM library developers.
115
>
rc, ok := r.rcByID[id]
116
>
if !ok {
118
>
}
120
}
121
122
// ComponentIDByFqn converts fully qualified component type name to component type ID.
123
// This method should only be used by CHASM framework internal code,
124
// NOT CHASM library developers.
125
func (r *Registry) ComponentIDByFqn(fqn string) (uint32, bool) {
126
rc, ok := r.rcByFqn[fqn]
127
if !ok {
128
return 0, false
129
}
130
return rc.componentID, true
131
}
132
133
// ComponentByID returns the registrable component for a given archetype ID.
134
// This method should only be used by CHASM framework internal code,
135
// NOT CHASM library developers.
137
>
rc, ok := r.rcByID[id]
138
>
return rc, ok
139
>
}
140
141
// ComponentIDFor converts registered component instance to component type ID.
142
// This method should only be used by CHASM framework internal code,
143
// NOT CHASM library developers.
145
>
rc, ok := r.componentFor(componentInstance)
146
>
if !ok {
147
return 0, false
148
}
150
}
151
152
// TaskByID returns the registrable task for a given task type ID.
153
// This method should only be used by CHASM framework internal code,
154
// NOT CHASM library developers.
156
>
rt, ok := r.rtByID[id]
157
>
return rt, ok
158
>
}
159
160
// TaskFqnByID converts task type ID to fully qualified task type name.
161
// This method should only be used by CHASM framework internal code,
162
// NOT CHASM library developers.
164
>
rt, ok := r.rtByID[id]
165
>
if !ok {
167
>
}
169
}
170
171
// TaskIDFor converts registered task instance to task type ID.
172
// This method should only be used by CHASM framework internal code,
173
// NOT CHASM library developers.
174
>
func (r *Registry) TaskIDFor(taskInstance any) (uint32, bool) {
visibility_queue_task_executor.go ×6
175
>
rt, ok := r.taskFor(taskInstance)
176
>
if !ok {
177
return 0, false
178
}
180
}
181
182
// ArchetypeDisplayName returns the human-readable name for a given archetype ID.
183
// This method should only be used by CHASM framework internal code,
184
// NOT CHASM library developers.
186
>
rc, ok := r.ComponentByID(id)
187
>
if !ok {
189
>
}
191
}
192
193
// ArchetypeIDOf returns the ArchetypeID for the given component Go type.
194
// This method should only be used by CHASM framework internal code,
195
// NOT CHASM library developers.
196
>
func (r *Registry) ArchetypeIDOf(componentGoType reflect.Type) (ArchetypeID, bool) {
registry.go ×1
197
>
rc, ok := r.rcByGoType[componentGoType]
198
>
if !ok {
200
>
}
202
}
203
205
>
rc, ok := r.rcByFqn[fqn]
206
>
return rc, ok
207
>
}
208
210
>
rt, ok := r.rtByFqn[fqn]
211
>
return rt, ok
212
>
}
213
214
>
func (r *Registry) componentFor(componentInstance any) (*RegistrableComponent, bool) {
registry.go ×1
215
>
rc, ok := r.rcByGoType[reflect.TypeOf(componentInstance)]
216
>
return rc, ok
217
>
}
218
220
>
rt, ok := r.rtByGoType[reflect.TypeOf(taskInstance)]
221
>
return rt, ok
222
>
}
223
224
>
func (r *Registry) componentOf(componentGoType reflect.Type) (*RegistrableComponent, bool) {
registry.go ×1
225
>
rc, ok := r.rcByGoType[componentGoType]
226
>
return rc, ok
227
>
}
228
230
>
rt, ok := r.rtByGoType[taskGoType]
231
>
return rt, ok
232
>
}
233
234
func (r *Registry) registerComponent(
235
lib namer,
236
rc *RegistrableComponent,
238
>
if err := r.validate(rc); err != nil {
240
>
}
241
243
>
if err != nil {
245
>
}
246
249
>
}
250
252
return fmt.Errorf("component %s maps to a reserved archetype id %d, please use a different name", fqn, UnspecifiedArchetypeID)
253
}
254
256
return fmt.Errorf("component ID %d collision between %s and %s", id, fqn, existingComponent.fqType())
257
}
258
261
return fmt.Errorf("context value key %v registered by component %s conflicts with component %s", key, fqn, existingValue.fqn)
262
}
264
>
v: value,
265
>
fqn: fqn,
266
>
}
267
}
268
269
// rc.goType implements Component interface; therefore, it must be a struct.
270
// This check to protect against the interface itself being registered.
272
>
(rc.goType.Kind() == reflect.Pointer && rc.goType.Elem().Kind() == reflect.Struct)) {
273
>
return fmt.Errorf("component type %s must be struct or pointer to struct", rc.goType.String())
registry.go ×1
274
>
}
276
>
return fmt.Errorf("component type %s is already registered", rc.goType.String())
registry.go ×1
277
>
}
279
>
280
>
r.rcByFqn[fqn] = rc
281
>
r.rcByID[id] = rc
282
>
r.rcByGoType[rc.goType] = rc
283
>
return nil
284
}
285
287
>
if err := r.validateName(rc.componentType); err != nil {
289
>
}
291
}
292
293
func (r *Registry) registerTask(
294
lib namer,
295
rt *RegistrableTask,
297
>
if err := r.validateName(rt.taskType); err != nil {
299
>
}
300
302
>
if err != nil {
304
>
}
305
308
>
}
309
311
return fmt.Errorf("task type ID %d collision between %s and %s", id, fqn, existingTask.fqType())
312
}
313
315
>
(rt.goType.Kind() == reflect.Pointer && rt.goType.Elem().Kind() == reflect.Struct)) {
316
>
return fmt.Errorf("task type %s must be struct or pointer to struct", rt.goType.String())
registry.go ×1
317
>
}
320
>
}
322
>
(rt.componentGoType.Kind() == reflect.Struct ||
323
>
(rt.componentGoType.Kind() == reflect.Pointer && rt.componentGoType.Elem().Kind() == reflect.Struct)) &&
324
>
rt.componentGoType.AssignableTo(reflect.TypeFor[Component]())) {
325
return fmt.Errorf("component type %s must be and interface or struct that implements Component interface", rt.componentGoType.String())
326
}
327
329
>
r.rtByID[id] = rt
330
>
r.rtByGoType[rt.goType] = rt
331
>
return nil
332
}
333
335
>
if n == "" {
337
>
}
339
>
return fmt.Errorf("name %s is invalid. name must follow golang identifier rules: %s", n, nameValidator.String())
registry.go ×1
340
>
}
342
}
343
344
>
func (r *Registry) validateVisibilityBusinessIDAlias(rc *RegistrableComponent) error {
registry.go ×2
345
>
if !hasVisibilityField(rc.goType) {
347
>
}
348
// Archetypes that contain a Field[*Visibility] must specify WithBusinessIDAlias.
350
>
return fmt.Errorf("component %s has Field[*Visibility] but no businessID alias; use WithBusinessIDAlias option", rc.componentType)
registrable_component.go ×1
351
>
}
353
}
354
356
>
var unmanagedFields []string
357
>
for f := range unmanagedFieldsOf(rc.goType) {
359
>
}
362
>
"Warning: CHASM component %s declares state fields that won't be managed by CHASM:\n\t%s",
363
>
fqn,
364
>
strings.Join(unmanagedFields, "\n\t")))
365
>
}
366
}
367
369
>
if _, ok := r.nexusServices[svc.Name]; ok {
371
>
}
373
>
return nil
374
}
375
376
// NexusServices returns all registered Nexus services.
378
>
// Return a copy to prevent external modification
379
>
services := make(map[string]*nexus.Service, len(r.nexusServices))
380
>
maps.Copy(services, r.nexusServices)
381
>
return services
382
>
}
383
385
>
if v, ok := r.rcContextValues[key]; ok {
387
>
}
389
}