1// Daemon multiplexer wire schema: the broker-to-daemon conversation that
2// multiplexes independently cancellable logical streams over one pooled
3// physical connection.
4//
5// daemonmux is a third conversation, separate from the session protocol
6// (tags 1-32) and the broker protocol (client 101-111, server 201-209):
7// client tags 301-305 and server tags 401-406 are disjoint from every other
8// tag, and each direction is its own closed oneof union. The physical
9// preamble is a separate adapter message pair, not an envelope variant:
10// roles 5/6 negotiate the per-connection ceilings, the authenticated daemon
11// identity, and the accepted policy once, before any application message.
12//
13// MuxData, MuxClose, MuxReset, and MuxWindowUpdate are shared payloads carried in both
14// directions; MuxOpen carries the full stream identity, and every later
15// frame is routed by physical_stream_id alone.
16
17// Code generated by protoc-gen-go. DO NOT EDIT.
18// versions:
19// protoc-gen-go v1.36.12
20// protoc (unknown)
21// source: multiplex.proto
22
23package wire
24
25import (
26 protoreflect "google.golang.org/protobuf/reflect/protoreflect"
27 protoimpl "google.golang.org/protobuf/runtime/protoimpl"
28 reflect "reflect"
29 sync "sync"
30 unsafe "unsafe"
31)
32
33const (
34 // Verify that this generated code is sufficiently up-to-date.
35 _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
36 // Verify that runtime/protoimpl is sufficiently up-to-date.
37 _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
38)
39
40// MuxStreamRef identifies one logical stream multiplexed over one physical
41// daemon connection: the mux-local physical_stream_id asserted by the
42// opening side, the broker epoch and client connection that own the stream,
43// and the broker client_stream_id it carries. physical_stream_id never
44// crosses a physical connection; client_stream_id never crosses a broker
45// connection or epoch. Every numeric value is nonzero and connection_id is
46// exactly 16 bytes.
47type MuxStreamRef struct {
48 state protoimpl.MessageState `protogen:"open.v1"`
49 PhysicalStreamId uint64 `protobuf:"varint,1,opt,name=physical_stream_id,json=physicalStreamId,proto3" json:"physical_stream_id,omitempty"`
50 BrokerEpoch uint64 `protobuf:"varint,2,opt,name=broker_epoch,json=brokerEpoch,proto3" json:"broker_epoch,omitempty"`
51 ConnectionId []byte `protobuf:"bytes,3,opt,name=connection_id,json=connectionId,proto3" json:"connection_id,omitempty"` // exactly 16 bytes
52 ClientStreamId uint64 `protobuf:"varint,4,opt,name=client_stream_id,json=clientStreamId,proto3" json:"client_stream_id,omitempty"`
53 unknownFields protoimpl.UnknownFields
54 sizeCache protoimpl.SizeCache
55}
56
57func (x *MuxStreamRef) Reset() {
58 *x = MuxStreamRef{}
59 mi := &file_multiplex_proto_msgTypes[0]
60 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
61 ms.StoreMessageInfo(mi)
62}
63
64func (x *MuxStreamRef) String() string {
65 return protoimpl.X.MessageStringOf(x)
66}
67
68func (*MuxStreamRef) ProtoMessage() {}
69
70func (x *MuxStreamRef) ProtoReflect() protoreflect.Message {
71 mi := &file_multiplex_proto_msgTypes[0]
72 if x != nil {
73 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
74 if ms.LoadMessageInfo() == nil {
75 ms.StoreMessageInfo(mi)
76 }
77 return ms
78 }
79 return mi.MessageOf(x)
80}
81
82// Deprecated: Use MuxStreamRef.ProtoReflect.Descriptor instead.
83func (*MuxStreamRef) Descriptor() ([]byte, []int) {
84 return file_multiplex_proto_rawDescGZIP(), []int{0}
85}
86
87func (x *MuxStreamRef) GetPhysicalStreamId() uint64 {
88 if x != nil {
89 return x.PhysicalStreamId
90 }
91 return 0
92}
93
94func (x *MuxStreamRef) GetBrokerEpoch() uint64 {
95 if x != nil {
96 return x.BrokerEpoch
97 }
98 return 0
99}
100
101func (x *MuxStreamRef) GetConnectionId() []byte {
102 if x != nil {
103 return x.ConnectionId
104 }
105 return nil
106}
107
108func (x *MuxStreamRef) GetClientStreamId() uint64 {
109 if x != nil {
110 return x.ClientStreamId
111 }
112 return 0
113}
114
115// MuxOpen asks the daemon to open one independently cancellable logical
116// stream over the physical connection. env is the per-request session
117// environment and is never inherited from the broker process environment.
118// The daemon revalidates the exact session identity before attachment.
119// start_mode carries the broker's explicit daemon-start authorization so a
120// transport can never widen it into a spawn.
121type MuxOpen struct {
122 state protoimpl.MessageState `protogen:"open.v1"`
123 Ref *MuxStreamRef `protobuf:"bytes,1,opt,name=ref,proto3" json:"ref,omitempty"`
124 // Closed taxonomy: 1 = attachment, 2 = control, 3 = observation.
125 Purpose uint32 `protobuf:"varint,2,opt,name=purpose,proto3" json:"purpose,omitempty"`
126 Local bool `protobuf:"varint,3,opt,name=local,proto3" json:"local,omitempty"`
127 Endpoint string `protobuf:"bytes,4,opt,name=endpoint,proto3" json:"endpoint,omitempty"`
128 Registration *RemoteRegistration `protobuf:"bytes,5,opt,name=registration,proto3" json:"registration,omitempty"`
129 Target *ExactTarget `protobuf:"bytes,6,opt,name=target,proto3" json:"target,omitempty"`
130 Env []string `protobuf:"bytes,7,rep,name=env,proto3" json:"env,omitempty"`
131 Policy *BrokerWirePolicy `protobuf:"bytes,8,opt,name=policy,proto3" json:"policy,omitempty"`
132 // Closed attachment-admission taxonomy (ports.BrokerStreamAdmission):
133 // 0 = none (control/observation), 1 = exact attach/resume carrying
134 // target, 2 = create named carrying name, 3 = create ephemeral, 4 = attach
135 // named carrying name.
136 Admission uint32 `protobuf:"varint,9,opt,name=admission,proto3" json:"admission,omitempty"`
137 Name string `protobuf:"bytes,10,opt,name=name,proto3" json:"name,omitempty"`
138 // Closed daemon-start taxonomy (ports.BrokerDaemonStartMode): 1 =
139 // existing_only, 2 = start_if_needed. Always present; zero is refused.
140 StartMode uint32 `protobuf:"varint,11,opt,name=start_mode,json=startMode,proto3" json:"start_mode,omitempty"`
141 unknownFields protoimpl.UnknownFields
142 sizeCache protoimpl.SizeCache
143}
144
145func (x *MuxOpen) Reset() {
146 *x = MuxOpen{}
147 mi := &file_multiplex_proto_msgTypes[1]
148 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
149 ms.StoreMessageInfo(mi)
150}
151
152func (x *MuxOpen) String() string {
153 return protoimpl.X.MessageStringOf(x)
154}
155
156func (*MuxOpen) ProtoMessage() {}
157
158func (x *MuxOpen) ProtoReflect() protoreflect.Message {
159 mi := &file_multiplex_proto_msgTypes[1]
160 if x != nil {
161 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
162 if ms.LoadMessageInfo() == nil {
163 ms.StoreMessageInfo(mi)
164 }
165 return ms
166 }
167 return mi.MessageOf(x)
168}
169
170// Deprecated: Use MuxOpen.ProtoReflect.Descriptor instead.
171func (*MuxOpen) Descriptor() ([]byte, []int) {
172 return file_multiplex_proto_rawDescGZIP(), []int{1}
173}
174
175func (x *MuxOpen) GetRef() *MuxStreamRef {
176 if x != nil {
177 return x.Ref
178 }
179 return nil
180}
181
182func (x *MuxOpen) GetPurpose() uint32 {
183 if x != nil {
184 return x.Purpose
185 }
186 return 0
187}
188
189func (x *MuxOpen) GetLocal() bool {
190 if x != nil {
191 return x.Local
192 }
193 return false
194}
195
196func (x *MuxOpen) GetEndpoint() string {
197 if x != nil {
198 return x.Endpoint
199 }
200 return ""
201}
202
203func (x *MuxOpen) GetRegistration() *RemoteRegistration {
204 if x != nil {
205 return x.Registration
206 }
207 return nil
208}
209
210func (x *MuxOpen) GetTarget() *ExactTarget {
211 if x != nil {
212 return x.Target
213 }
214 return nil
215}
216
217func (x *MuxOpen) GetEnv() []string {
218 if x != nil {
219 return x.Env
220 }
221 return nil
222}
223
224func (x *MuxOpen) GetPolicy() *BrokerWirePolicy {
225 if x != nil {
226 return x.Policy
227 }
228 return nil
229}
230
231func (x *MuxOpen) GetAdmission() uint32 {
232 if x != nil {
233 return x.Admission
234 }
235 return 0
236}
237
238func (x *MuxOpen) GetName() string {
239 if x != nil {
240 return x.Name
241 }
242 return ""
243}
244
245func (x *MuxOpen) GetStartMode() uint32 {
246 if x != nil {
247 return x.StartMode
248 }
249 return 0
250}
251
252// MuxOpened confirms one logical stream is established.
253type MuxOpened struct {
254 state protoimpl.MessageState `protogen:"open.v1"`
255 Ref *MuxStreamRef `protobuf:"bytes,1,opt,name=ref,proto3" json:"ref,omitempty"`
256 unknownFields protoimpl.UnknownFields
257 sizeCache protoimpl.SizeCache
258}
259
260func (x *MuxOpened) Reset() {
261 *x = MuxOpened{}
262 mi := &file_multiplex_proto_msgTypes[2]
263 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
264 ms.StoreMessageInfo(mi)
265}
266
267func (x *MuxOpened) String() string {
268 return protoimpl.X.MessageStringOf(x)
269}
270
271func (*MuxOpened) ProtoMessage() {}
272
273func (x *MuxOpened) ProtoReflect() protoreflect.Message {
274 mi := &file_multiplex_proto_msgTypes[2]
275 if x != nil {
276 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
277 if ms.LoadMessageInfo() == nil {
278 ms.StoreMessageInfo(mi)
279 }
280 return ms
281 }
282 return mi.MessageOf(x)
283}
284
285// Deprecated: Use MuxOpened.ProtoReflect.Descriptor instead.
286func (*MuxOpened) Descriptor() ([]byte, []int) {
287 return file_multiplex_proto_rawDescGZIP(), []int{2}
288}
289
290func (x *MuxOpened) GetRef() *MuxStreamRef {
291 if x != nil {
292 return x.Ref
293 }
294 return nil
295}
296
297// MuxRefused refuses one logical stream open. The typed error is
298// mandatory: a refusal without a reason could not be classified.
299type MuxRefused struct {
300 state protoimpl.MessageState `protogen:"open.v1"`
301 Ref *MuxStreamRef `protobuf:"bytes,1,opt,name=ref,proto3" json:"ref,omitempty"`
302 Error *BrokerErrorDetail `protobuf:"bytes,2,opt,name=error,proto3" json:"error,omitempty"`
303 unknownFields protoimpl.UnknownFields
304 sizeCache protoimpl.SizeCache
305}
306
307func (x *MuxRefused) Reset() {
308 *x = MuxRefused{}
309 mi := &file_multiplex_proto_msgTypes[3]
310 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
311 ms.StoreMessageInfo(mi)
312}
313
314func (x *MuxRefused) String() string {
315 return protoimpl.X.MessageStringOf(x)
316}
317
318func (*MuxRefused) ProtoMessage() {}
319
320func (x *MuxRefused) ProtoReflect() protoreflect.Message {
321 mi := &file_multiplex_proto_msgTypes[3]
322 if x != nil {
323 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
324 if ms.LoadMessageInfo() == nil {
325 ms.StoreMessageInfo(mi)
326 }
327 return ms
328 }
329 return mi.MessageOf(x)
330}
331
332// Deprecated: Use MuxRefused.ProtoReflect.Descriptor instead.
333func (*MuxRefused) Descriptor() ([]byte, []int) {
334 return file_multiplex_proto_rawDescGZIP(), []int{3}
335}
336
337func (x *MuxRefused) GetRef() *MuxStreamRef {
338 if x != nil {
339 return x.Ref
340 }
341 return nil
342}
343
344func (x *MuxRefused) GetError() *BrokerErrorDetail {
345 if x != nil {
346 return x.Error
347 }
348 return nil
349}
350
351// MuxData carries one opaque stream frame in either direction. Once a
352// stream is opened it is routed by physical_stream_id alone and never
353// repeats its scope.
354type MuxData struct {
355 state protoimpl.MessageState `protogen:"open.v1"`
356 PhysicalStreamId uint64 `protobuf:"varint,1,opt,name=physical_stream_id,json=physicalStreamId,proto3" json:"physical_stream_id,omitempty"`
357 Data []byte `protobuf:"bytes,2,opt,name=data,proto3" json:"data,omitempty"`
358 unknownFields protoimpl.UnknownFields
359 sizeCache protoimpl.SizeCache
360}
361
362func (x *MuxData) Reset() {
363 *x = MuxData{}
364 mi := &file_multiplex_proto_msgTypes[4]
365 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
366 ms.StoreMessageInfo(mi)
367}
368
369func (x *MuxData) String() string {
370 return protoimpl.X.MessageStringOf(x)
371}
372
373func (*MuxData) ProtoMessage() {}
374
375func (x *MuxData) ProtoReflect() protoreflect.Message {
376 mi := &file_multiplex_proto_msgTypes[4]
377 if x != nil {
378 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
379 if ms.LoadMessageInfo() == nil {
380 ms.StoreMessageInfo(mi)
381 }
382 return ms
383 }
384 return mi.MessageOf(x)
385}
386
387// Deprecated: Use MuxData.ProtoReflect.Descriptor instead.
388func (*MuxData) Descriptor() ([]byte, []int) {
389 return file_multiplex_proto_rawDescGZIP(), []int{4}
390}
391
392func (x *MuxData) GetPhysicalStreamId() uint64 {
393 if x != nil {
394 return x.PhysicalStreamId
395 }
396 return 0
397}
398
399func (x *MuxData) GetData() []byte {
400 if x != nil {
401 return x.Data
402 }
403 return nil
404}
405
406// MuxClose ends one logical stream in either direction.
407type MuxClose struct {
408 state protoimpl.MessageState `protogen:"open.v1"`
409 PhysicalStreamId uint64 `protobuf:"varint,1,opt,name=physical_stream_id,json=physicalStreamId,proto3" json:"physical_stream_id,omitempty"`
410 unknownFields protoimpl.UnknownFields
411 sizeCache protoimpl.SizeCache
412}
413
414func (x *MuxClose) Reset() {
415 *x = MuxClose{}
416 mi := &file_multiplex_proto_msgTypes[5]
417 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
418 ms.StoreMessageInfo(mi)
419}
420
421func (x *MuxClose) String() string {
422 return protoimpl.X.MessageStringOf(x)
423}
424
425func (*MuxClose) ProtoMessage() {}
426
427func (x *MuxClose) ProtoReflect() protoreflect.Message {
428 mi := &file_multiplex_proto_msgTypes[5]
429 if x != nil {
430 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
431 if ms.LoadMessageInfo() == nil {
432 ms.StoreMessageInfo(mi)
433 }
434 return ms
435 }
436 return mi.MessageOf(x)
437}
438
439// Deprecated: Use MuxClose.ProtoReflect.Descriptor instead.
440func (*MuxClose) Descriptor() ([]byte, []int) {
441 return file_multiplex_proto_rawDescGZIP(), []int{5}
442}
443
444func (x *MuxClose) GetPhysicalStreamId() uint64 {
445 if x != nil {
446 return x.PhysicalStreamId
447 }
448 return 0
449}
450
451// MuxReset aborts one logical stream in either direction. An unset error is
452// an abort without a typed reason; a set error carries the failure.
453type MuxReset struct {
454 state protoimpl.MessageState `protogen:"open.v1"`
455 PhysicalStreamId uint64 `protobuf:"varint,1,opt,name=physical_stream_id,json=physicalStreamId,proto3" json:"physical_stream_id,omitempty"`
456 Error *BrokerErrorDetail `protobuf:"bytes,2,opt,name=error,proto3" json:"error,omitempty"`
457 unknownFields protoimpl.UnknownFields
458 sizeCache protoimpl.SizeCache
459}
460
461func (x *MuxReset) Reset() {
462 *x = MuxReset{}
463 mi := &file_multiplex_proto_msgTypes[6]
464 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
465 ms.StoreMessageInfo(mi)
466}
467
468func (x *MuxReset) String() string {
469 return protoimpl.X.MessageStringOf(x)
470}
471
472func (*MuxReset) ProtoMessage() {}
473
474func (x *MuxReset) ProtoReflect() protoreflect.Message {
475 mi := &file_multiplex_proto_msgTypes[6]
476 if x != nil {
477 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
478 if ms.LoadMessageInfo() == nil {
479 ms.StoreMessageInfo(mi)
480 }
481 return ms
482 }
483 return mi.MessageOf(x)
484}
485
486// Deprecated: Use MuxReset.ProtoReflect.Descriptor instead.
487func (*MuxReset) Descriptor() ([]byte, []int) {
488 return file_multiplex_proto_rawDescGZIP(), []int{6}
489}
490
491func (x *MuxReset) GetPhysicalStreamId() uint64 {
492 if x != nil {
493 return x.PhysicalStreamId
494 }
495 return 0
496}
497
498func (x *MuxReset) GetError() *BrokerErrorDetail {
499 if x != nil {
500 return x.Error
501 }
502 return nil
503}
504
505// MuxWindowUpdate returns receive credit for one logical stream in either
506// direction: the receiver consumed MuxData frames worth `credit_bytes` credit
507// bytes, so the sender may spend that many more. One MuxData frame costs its
508// payload length plus 64 credit bytes. Each stream starts with the same window
509// on both sides, derived from the negotiated ceilings; a sender never has more
510// credit in flight than its window, so a slow receiver slows the sender
511// instead of overflowing its queue.
512type MuxWindowUpdate struct {
513 state protoimpl.MessageState `protogen:"open.v1"`
514 PhysicalStreamId uint64 `protobuf:"varint,1,opt,name=physical_stream_id,json=physicalStreamId,proto3" json:"physical_stream_id,omitempty"`
515 CreditBytes uint64 `protobuf:"varint,2,opt,name=credit_bytes,json=creditBytes,proto3" json:"credit_bytes,omitempty"`
516 unknownFields protoimpl.UnknownFields
517 sizeCache protoimpl.SizeCache
518}
519
520func (x *MuxWindowUpdate) Reset() {
521 *x = MuxWindowUpdate{}
522 mi := &file_multiplex_proto_msgTypes[7]
523 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
524 ms.StoreMessageInfo(mi)
525}
526
527func (x *MuxWindowUpdate) String() string {
528 return protoimpl.X.MessageStringOf(x)
529}
530
531func (*MuxWindowUpdate) ProtoMessage() {}
532
533func (x *MuxWindowUpdate) ProtoReflect() protoreflect.Message {
534 mi := &file_multiplex_proto_msgTypes[7]
535 if x != nil {
536 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
537 if ms.LoadMessageInfo() == nil {
538 ms.StoreMessageInfo(mi)
539 }
540 return ms
541 }
542 return mi.MessageOf(x)
543}
544
545// Deprecated: Use MuxWindowUpdate.ProtoReflect.Descriptor instead.
546func (*MuxWindowUpdate) Descriptor() ([]byte, []int) {
547 return file_multiplex_proto_rawDescGZIP(), []int{7}
548}
549
550func (x *MuxWindowUpdate) GetPhysicalStreamId() uint64 {
551 if x != nil {
552 return x.PhysicalStreamId
553 }
554 return 0
555}
556
557func (x *MuxWindowUpdate) GetCreditBytes() uint64 {
558 if x != nil {
559 return x.CreditBytes
560 }
561 return 0
562}
563
564// MuxClientEnvelope is the closed broker-to-daemon mux union. Exactly one
565// variant must be set per envelope; empty, duplicate, and wrong-direction
566// payloads are rejected before generated unmarshal.
567type MuxClientEnvelope struct {
568 state protoimpl.MessageState `protogen:"open.v1"`
569 // Types that are valid to be assigned to Payload:
570 //
571 // *MuxClientEnvelope_Open
572 // *MuxClientEnvelope_Data
573 // *MuxClientEnvelope_Close
574 // *MuxClientEnvelope_Reset_
575 // *MuxClientEnvelope_WindowUpdate
576 Payload isMuxClientEnvelope_Payload `protobuf_oneof:"payload"`
577 unknownFields protoimpl.UnknownFields
578 sizeCache protoimpl.SizeCache
579}
580
581func (x *MuxClientEnvelope) Reset() {
582 *x = MuxClientEnvelope{}
583 mi := &file_multiplex_proto_msgTypes[8]
584 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
585 ms.StoreMessageInfo(mi)
586}
587
588func (x *MuxClientEnvelope) String() string {
589 return protoimpl.X.MessageStringOf(x)
590}
591
592func (*MuxClientEnvelope) ProtoMessage() {}
593
594func (x *MuxClientEnvelope) ProtoReflect() protoreflect.Message {
595 mi := &file_multiplex_proto_msgTypes[8]
596 if x != nil {
597 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
598 if ms.LoadMessageInfo() == nil {
599 ms.StoreMessageInfo(mi)
600 }
601 return ms
602 }
603 return mi.MessageOf(x)
604}
605
606// Deprecated: Use MuxClientEnvelope.ProtoReflect.Descriptor instead.
607func (*MuxClientEnvelope) Descriptor() ([]byte, []int) {
608 return file_multiplex_proto_rawDescGZIP(), []int{8}
609}
610
611func (x *MuxClientEnvelope) GetPayload() isMuxClientEnvelope_Payload {
612 if x != nil {
613 return x.Payload
614 }
615 return nil
616}
617
618func (x *MuxClientEnvelope) GetOpen() *MuxOpen {
619 if x != nil {
620 if x, ok := x.Payload.(*MuxClientEnvelope_Open); ok {
621 return x.Open
622 }
623 }
624 return nil
625}
626
627func (x *MuxClientEnvelope) GetData() *MuxData {
628 if x != nil {
629 if x, ok := x.Payload.(*MuxClientEnvelope_Data); ok {
630 return x.Data
631 }
632 }
633 return nil
634}
635
636func (x *MuxClientEnvelope) GetClose() *MuxClose {
637 if x != nil {
638 if x, ok := x.Payload.(*MuxClientEnvelope_Close); ok {
639 return x.Close
640 }
641 }
642 return nil
643}
644
645func (x *MuxClientEnvelope) GetReset_() *MuxReset {
646 if x != nil {
647 if x, ok := x.Payload.(*MuxClientEnvelope_Reset_); ok {
648 return x.Reset_
649 }
650 }
651 return nil
652}
653
654func (x *MuxClientEnvelope) GetWindowUpdate() *MuxWindowUpdate {
655 if x != nil {
656 if x, ok := x.Payload.(*MuxClientEnvelope_WindowUpdate); ok {
657 return x.WindowUpdate
658 }
659 }
660 return nil
661}
662
663type isMuxClientEnvelope_Payload interface {
664 isMuxClientEnvelope_Payload()
665}
666
667type MuxClientEnvelope_Open struct {
668 Open *MuxOpen `protobuf:"bytes,301,opt,name=open,proto3,oneof"`
669}
670
671type MuxClientEnvelope_Data struct {
672 Data *MuxData `protobuf:"bytes,302,opt,name=data,proto3,oneof"`
673}
674
675type MuxClientEnvelope_Close struct {
676 Close *MuxClose `protobuf:"bytes,303,opt,name=close,proto3,oneof"`
677}
678
679type MuxClientEnvelope_Reset_ struct {
680 Reset_ *MuxReset `protobuf:"bytes,304,opt,name=reset,proto3,oneof"`
681}
682
683type MuxClientEnvelope_WindowUpdate struct {
684 WindowUpdate *MuxWindowUpdate `protobuf:"bytes,305,opt,name=window_update,json=windowUpdate,proto3,oneof"`
685}
686
687func (*MuxClientEnvelope_Open) isMuxClientEnvelope_Payload() {}
688
689func (*MuxClientEnvelope_Data) isMuxClientEnvelope_Payload() {}
690
691func (*MuxClientEnvelope_Close) isMuxClientEnvelope_Payload() {}
692
693func (*MuxClientEnvelope_Reset_) isMuxClientEnvelope_Payload() {}
694
695func (*MuxClientEnvelope_WindowUpdate) isMuxClientEnvelope_Payload() {}
696
697// MuxServerEnvelope is the closed daemon-to-broker mux union. Exactly one
698// variant must be set per envelope.
699type MuxServerEnvelope struct {
700 state protoimpl.MessageState `protogen:"open.v1"`
701 // Types that are valid to be assigned to Payload:
702 //
703 // *MuxServerEnvelope_Opened
704 // *MuxServerEnvelope_Refused
705 // *MuxServerEnvelope_Data
706 // *MuxServerEnvelope_Close
707 // *MuxServerEnvelope_Reset_
708 // *MuxServerEnvelope_WindowUpdate
709 Payload isMuxServerEnvelope_Payload `protobuf_oneof:"payload"`
710 unknownFields protoimpl.UnknownFields
711 sizeCache protoimpl.SizeCache
712}
713
714func (x *MuxServerEnvelope) Reset() {
715 *x = MuxServerEnvelope{}
716 mi := &file_multiplex_proto_msgTypes[9]
717 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
718 ms.StoreMessageInfo(mi)
719}
720
721func (x *MuxServerEnvelope) String() string {
722 return protoimpl.X.MessageStringOf(x)
723}
724
725func (*MuxServerEnvelope) ProtoMessage() {}
726
727func (x *MuxServerEnvelope) ProtoReflect() protoreflect.Message {
728 mi := &file_multiplex_proto_msgTypes[9]
729 if x != nil {
730 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
731 if ms.LoadMessageInfo() == nil {
732 ms.StoreMessageInfo(mi)
733 }
734 return ms
735 }
736 return mi.MessageOf(x)
737}
738
739// Deprecated: Use MuxServerEnvelope.ProtoReflect.Descriptor instead.
740func (*MuxServerEnvelope) Descriptor() ([]byte, []int) {
741 return file_multiplex_proto_rawDescGZIP(), []int{9}
742}
743
744func (x *MuxServerEnvelope) GetPayload() isMuxServerEnvelope_Payload {
745 if x != nil {
746 return x.Payload
747 }
748 return nil
749}
750
751func (x *MuxServerEnvelope) GetOpened() *MuxOpened {
752 if x != nil {
753 if x, ok := x.Payload.(*MuxServerEnvelope_Opened); ok {
754 return x.Opened
755 }
756 }
757 return nil
758}
759
760func (x *MuxServerEnvelope) GetRefused() *MuxRefused {
761 if x != nil {
762 if x, ok := x.Payload.(*MuxServerEnvelope_Refused); ok {
763 return x.Refused
764 }
765 }
766 return nil
767}
768
769func (x *MuxServerEnvelope) GetData() *MuxData {
770 if x != nil {
771 if x, ok := x.Payload.(*MuxServerEnvelope_Data); ok {
772 return x.Data
773 }
774 }
775 return nil
776}
777
778func (x *MuxServerEnvelope) GetClose() *MuxClose {
779 if x != nil {
780 if x, ok := x.Payload.(*MuxServerEnvelope_Close); ok {
781 return x.Close
782 }
783 }
784 return nil
785}
786
787func (x *MuxServerEnvelope) GetReset_() *MuxReset {
788 if x != nil {
789 if x, ok := x.Payload.(*MuxServerEnvelope_Reset_); ok {
790 return x.Reset_
791 }
792 }
793 return nil
794}
795
796func (x *MuxServerEnvelope) GetWindowUpdate() *MuxWindowUpdate {
797 if x != nil {
798 if x, ok := x.Payload.(*MuxServerEnvelope_WindowUpdate); ok {
799 return x.WindowUpdate
800 }
801 }
802 return nil
803}
804
805type isMuxServerEnvelope_Payload interface {
806 isMuxServerEnvelope_Payload()
807}
808
809type MuxServerEnvelope_Opened struct {
810 Opened *MuxOpened `protobuf:"bytes,401,opt,name=opened,proto3,oneof"`
811}
812
813type MuxServerEnvelope_Refused struct {
814 Refused *MuxRefused `protobuf:"bytes,402,opt,name=refused,proto3,oneof"`
815}
816
817type MuxServerEnvelope_Data struct {
818 Data *MuxData `protobuf:"bytes,403,opt,name=data,proto3,oneof"`
819}
820
821type MuxServerEnvelope_Close struct {
822 Close *MuxClose `protobuf:"bytes,404,opt,name=close,proto3,oneof"`
823}
824
825type MuxServerEnvelope_Reset_ struct {
826 Reset_ *MuxReset `protobuf:"bytes,405,opt,name=reset,proto3,oneof"`
827}
828
829type MuxServerEnvelope_WindowUpdate struct {
830 WindowUpdate *MuxWindowUpdate `protobuf:"bytes,406,opt,name=window_update,json=windowUpdate,proto3,oneof"`
831}
832
833func (*MuxServerEnvelope_Opened) isMuxServerEnvelope_Payload() {}
834
835func (*MuxServerEnvelope_Refused) isMuxServerEnvelope_Payload() {}
836
837func (*MuxServerEnvelope_Data) isMuxServerEnvelope_Payload() {}
838
839func (*MuxServerEnvelope_Close) isMuxServerEnvelope_Payload() {}
840
841func (*MuxServerEnvelope_Reset_) isMuxServerEnvelope_Payload() {}
842
843func (*MuxServerEnvelope_WindowUpdate) isMuxServerEnvelope_Payload() {}
844
845// MuxPreambleRequest is the daemonmux client's first frame on one physical
846// connection: the requested per-connection ceilings and the broker policy
847// the client asks the daemon to accept. The shared field numbers mirror
848// MuxPreambleResponse, exactly as the session preamble pair does. Each
849// ceiling is advertised independently per direction: max_aggregate_bytes is
850// the buffered-bytes budget the client will enforce in the direction it
851// accepts, and never shared with the opposite direction.
852type MuxPreambleRequest struct {
853 state protoimpl.MessageState `protogen:"open.v1"`
854 Magic uint32 `protobuf:"varint,1,opt,name=magic,proto3" json:"magic,omitempty"` // must equal the shared preamble magic
855 Epoch uint32 `protobuf:"varint,2,opt,name=epoch,proto3" json:"epoch,omitempty"` // must equal the shared protocol epoch
856 Version uint32 `protobuf:"varint,3,opt,name=version,proto3" json:"version,omitempty"` // exact session protocol version
857 Role *PreambleRole `protobuf:"bytes,4,opt,name=role,proto3" json:"role,omitempty"` // must be 5 (daemonmux client)
858 MaxReceiveEnvelopeBytes uint64 `protobuf:"varint,5,opt,name=max_receive_envelope_bytes,json=maxReceiveEnvelopeBytes,proto3" json:"max_receive_envelope_bytes,omitempty"` // requested 1 MiB..16 MiB
859 StreamChunkLimit uint64 `protobuf:"varint,6,opt,name=stream_chunk_limit,json=streamChunkLimit,proto3" json:"stream_chunk_limit,omitempty"` // requested 1..64 KiB
860 MaxStreams uint64 `protobuf:"varint,7,opt,name=max_streams,json=maxStreams,proto3" json:"max_streams,omitempty"` // requested 1..128
861 MaxAggregateBytes uint64 `protobuf:"varint,8,opt,name=max_aggregate_bytes,json=maxAggregateBytes,proto3" json:"max_aggregate_bytes,omitempty"` // requested 1 max chunk + overhead..64 MiB, per direction
862 CapabilityBits uint32 `protobuf:"varint,9,opt,name=capability_bits,json=capabilityBits,proto3" json:"capability_bits,omitempty"` // must be zero
863 Policy *BrokerWirePolicy `protobuf:"bytes,10,opt,name=policy,proto3" json:"policy,omitempty"` // requested connection policy
864 unknownFields protoimpl.UnknownFields
865 sizeCache protoimpl.SizeCache
866}
867
868func (x *MuxPreambleRequest) Reset() {
869 *x = MuxPreambleRequest{}
870 mi := &file_multiplex_proto_msgTypes[10]
871 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
872 ms.StoreMessageInfo(mi)
873}
874
875func (x *MuxPreambleRequest) String() string {
876 return protoimpl.X.MessageStringOf(x)
877}
878
879func (*MuxPreambleRequest) ProtoMessage() {}
880
881func (x *MuxPreambleRequest) ProtoReflect() protoreflect.Message {
882 mi := &file_multiplex_proto_msgTypes[10]
883 if x != nil {
884 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
885 if ms.LoadMessageInfo() == nil {
886 ms.StoreMessageInfo(mi)
887 }
888 return ms
889 }
890 return mi.MessageOf(x)
891}
892
893// Deprecated: Use MuxPreambleRequest.ProtoReflect.Descriptor instead.
894func (*MuxPreambleRequest) Descriptor() ([]byte, []int) {
895 return file_multiplex_proto_rawDescGZIP(), []int{10}
896}
897
898func (x *MuxPreambleRequest) GetMagic() uint32 {
899 if x != nil {
900 return x.Magic
901 }
902 return 0
903}
904
905func (x *MuxPreambleRequest) GetEpoch() uint32 {
906 if x != nil {
907 return x.Epoch
908 }
909 return 0
910}
911
912func (x *MuxPreambleRequest) GetVersion() uint32 {
913 if x != nil {
914 return x.Version
915 }
916 return 0
917}
918
919func (x *MuxPreambleRequest) GetRole() *PreambleRole {
920 if x != nil {
921 return x.Role
922 }
923 return nil
924}
925
926func (x *MuxPreambleRequest) GetMaxReceiveEnvelopeBytes() uint64 {
927 if x != nil {
928 return x.MaxReceiveEnvelopeBytes
929 }
930 return 0
931}
932
933func (x *MuxPreambleRequest) GetStreamChunkLimit() uint64 {
934 if x != nil {
935 return x.StreamChunkLimit
936 }
937 return 0
938}
939
940func (x *MuxPreambleRequest) GetMaxStreams() uint64 {
941 if x != nil {
942 return x.MaxStreams
943 }
944 return 0
945}
946
947func (x *MuxPreambleRequest) GetMaxAggregateBytes() uint64 {
948 if x != nil {
949 return x.MaxAggregateBytes
950 }
951 return 0
952}
953
954func (x *MuxPreambleRequest) GetCapabilityBits() uint32 {
955 if x != nil {
956 return x.CapabilityBits
957 }
958 return 0
959}
960
961func (x *MuxPreambleRequest) GetPolicy() *BrokerWirePolicy {
962 if x != nil {
963 return x.Policy
964 }
965 return nil
966}
967
968// MuxPreambleResponse is the daemon's first frame: acceptance carrying the
969// effective (minimum) ceilings, the authenticated daemon identity and
970// incarnation, and the accepted policy, or a typed refusal. The effective
971// ceilings never exceed the client's offer, and max_aggregate_bytes stays a
972// per-direction budget: the daemon enforces the effective value
973// independently in each direction it buffers.
974type MuxPreambleResponse struct {
975 state protoimpl.MessageState `protogen:"open.v1"`
976 Magic uint32 `protobuf:"varint,1,opt,name=magic,proto3" json:"magic,omitempty"`
977 Epoch uint32 `protobuf:"varint,2,opt,name=epoch,proto3" json:"epoch,omitempty"`
978 Version uint32 `protobuf:"varint,3,opt,name=version,proto3" json:"version,omitempty"`
979 Role *PreambleRole `protobuf:"bytes,4,opt,name=role,proto3" json:"role,omitempty"` // must be 6 (daemonmux server)
980 MaxReceiveEnvelopeBytes uint64 `protobuf:"varint,5,opt,name=max_receive_envelope_bytes,json=maxReceiveEnvelopeBytes,proto3" json:"max_receive_envelope_bytes,omitempty"` // effective ceiling
981 StreamChunkLimit uint64 `protobuf:"varint,6,opt,name=stream_chunk_limit,json=streamChunkLimit,proto3" json:"stream_chunk_limit,omitempty"` // effective ceiling
982 MaxStreams uint64 `protobuf:"varint,7,opt,name=max_streams,json=maxStreams,proto3" json:"max_streams,omitempty"` // effective ceiling
983 MaxAggregateBytes uint64 `protobuf:"varint,8,opt,name=max_aggregate_bytes,json=maxAggregateBytes,proto3" json:"max_aggregate_bytes,omitempty"` // effective ceiling, per direction, never above the offer
984 CapabilityBits uint32 `protobuf:"varint,9,opt,name=capability_bits,json=capabilityBits,proto3" json:"capability_bits,omitempty"` // must be zero
985 AcceptedPolicy *BrokerWirePolicy `protobuf:"bytes,10,opt,name=accepted_policy,json=acceptedPolicy,proto3" json:"accepted_policy,omitempty"` // daemon-authoritative policy
986 Accepted bool `protobuf:"varint,11,opt,name=accepted,proto3" json:"accepted,omitempty"`
987 Rejection *PreambleRejectionCode `protobuf:"bytes,12,opt,name=rejection,proto3" json:"rejection,omitempty"` // set only when accepted is false
988 DaemonIdentity string `protobuf:"bytes,13,opt,name=daemon_identity,json=daemonIdentity,proto3" json:"daemon_identity,omitempty"` // authenticated identity token
989 Incarnation []byte `protobuf:"bytes,14,opt,name=incarnation,proto3" json:"incarnation,omitempty"` // exactly 16 bytes
990 unknownFields protoimpl.UnknownFields
991 sizeCache protoimpl.SizeCache
992}
993
994func (x *MuxPreambleResponse) Reset() {
995 *x = MuxPreambleResponse{}
996 mi := &file_multiplex_proto_msgTypes[11]
997 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
998 ms.StoreMessageInfo(mi)
999}
1000
1001func (x *MuxPreambleResponse) String() string {
1002 return protoimpl.X.MessageStringOf(x)
1003}
1004
1005func (*MuxPreambleResponse) ProtoMessage() {}
1006
1007func (x *MuxPreambleResponse) ProtoReflect() protoreflect.Message {
1008 mi := &file_multiplex_proto_msgTypes[11]
1009 if x != nil {
1010 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
1011 if ms.LoadMessageInfo() == nil {
1012 ms.StoreMessageInfo(mi)
1013 }
1014 return ms
1015 }
1016 return mi.MessageOf(x)
1017}
1018
1019// Deprecated: Use MuxPreambleResponse.ProtoReflect.Descriptor instead.
1020func (*MuxPreambleResponse) Descriptor() ([]byte, []int) {
1021 return file_multiplex_proto_rawDescGZIP(), []int{11}
1022}
1023
1024func (x *MuxPreambleResponse) GetMagic() uint32 {
1025 if x != nil {
1026 return x.Magic
1027 }
1028 return 0
1029}
1030
1031func (x *MuxPreambleResponse) GetEpoch() uint32 {
1032 if x != nil {
1033 return x.Epoch
1034 }
1035 return 0
1036}
1037
1038func (x *MuxPreambleResponse) GetVersion() uint32 {
1039 if x != nil {
1040 return x.Version
1041 }
1042 return 0
1043}
1044
1045func (x *MuxPreambleResponse) GetRole() *PreambleRole {
1046 if x != nil {
1047 return x.Role
1048 }
1049 return nil
1050}
1051
1052func (x *MuxPreambleResponse) GetMaxReceiveEnvelopeBytes() uint64 {
1053 if x != nil {
1054 return x.MaxReceiveEnvelopeBytes
1055 }
1056 return 0
1057}
1058
1059func (x *MuxPreambleResponse) GetStreamChunkLimit() uint64 {
1060 if x != nil {
1061 return x.StreamChunkLimit
1062 }
1063 return 0
1064}
1065
1066func (x *MuxPreambleResponse) GetMaxStreams() uint64 {
1067 if x != nil {
1068 return x.MaxStreams
1069 }
1070 return 0
1071}
1072
1073func (x *MuxPreambleResponse) GetMaxAggregateBytes() uint64 {
1074 if x != nil {
1075 return x.MaxAggregateBytes
1076 }
1077 return 0
1078}
1079
1080func (x *MuxPreambleResponse) GetCapabilityBits() uint32 {
1081 if x != nil {
1082 return x.CapabilityBits
1083 }
1084 return 0
1085}
1086
1087func (x *MuxPreambleResponse) GetAcceptedPolicy() *BrokerWirePolicy {
1088 if x != nil {
1089 return x.AcceptedPolicy
1090 }
1091 return nil
1092}
1093
1094func (x *MuxPreambleResponse) GetAccepted() bool {
1095 if x != nil {
1096 return x.Accepted
1097 }
1098 return false
1099}
1100
1101func (x *MuxPreambleResponse) GetRejection() *PreambleRejectionCode {
1102 if x != nil {
1103 return x.Rejection
1104 }
1105 return nil
1106}
1107
1108func (x *MuxPreambleResponse) GetDaemonIdentity() string {
1109 if x != nil {
1110 return x.DaemonIdentity
1111 }
1112 return ""
1113}
1114
1115func (x *MuxPreambleResponse) GetIncarnation() []byte {
1116 if x != nil {
1117 return x.Incarnation
1118 }
1119 return nil
1120}
1121
1122var File_multiplex_proto protoreflect.FileDescriptor
1123
1124const file_multiplex_proto_rawDesc = "" +
1125 "\n" +
1126 "\x0fmultiplex.proto\x12\vvev.wire.v1\x1a\fbroker.proto\x1a\fcommon.proto\x1a\x0eenvelope.proto\"\xae\x01\n" +
1127 "\fMuxStreamRef\x12,\n" +
1128 "\x12physical_stream_id\x18\x01 \x01(\x04R\x10physicalStreamId\x12!\n" +
1129 "\fbroker_epoch\x18\x02 \x01(\x04R\vbrokerEpoch\x12#\n" +
1130 "\rconnection_id\x18\x03 \x01(\fR\fconnectionId\x12(\n" +
1131 "\x10client_stream_id\x18\x04 \x01(\x04R\x0eclientStreamId\"\x93\x03\n" +
1132 "\aMuxOpen\x12+\n" +
1133 "\x03ref\x18\x01 \x01(\v2\x19.vev.wire.v1.MuxStreamRefR\x03ref\x12\x18\n" +
1134 "\apurpose\x18\x02 \x01(\rR\apurpose\x12\x14\n" +
1135 "\x05local\x18\x03 \x01(\bR\x05local\x12\x1a\n" +
1136 "\bendpoint\x18\x04 \x01(\tR\bendpoint\x12C\n" +
1137 "\fregistration\x18\x05 \x01(\v2\x1f.vev.wire.v1.RemoteRegistrationR\fregistration\x120\n" +
1138 "\x06target\x18\x06 \x01(\v2\x18.vev.wire.v1.ExactTargetR\x06target\x12\x10\n" +
1139 "\x03env\x18\a \x03(\tR\x03env\x125\n" +
1140 "\x06policy\x18\b \x01(\v2\x1d.vev.wire.v1.BrokerWirePolicyR\x06policy\x12\x1c\n" +
1141 "\tadmission\x18\t \x01(\rR\tadmission\x12\x12\n" +
1142 "\x04name\x18\n" +
1143 " \x01(\tR\x04name\x12\x1d\n" +
1144 "\n" +
1145 "start_mode\x18\v \x01(\rR\tstartMode\"8\n" +
1146 "\tMuxOpened\x12+\n" +
1147 "\x03ref\x18\x01 \x01(\v2\x19.vev.wire.v1.MuxStreamRefR\x03ref\"o\n" +
1148 "\n" +
1149 "MuxRefused\x12+\n" +
1150 "\x03ref\x18\x01 \x01(\v2\x19.vev.wire.v1.MuxStreamRefR\x03ref\x124\n" +
1151 "\x05error\x18\x02 \x01(\v2\x1e.vev.wire.v1.BrokerErrorDetailR\x05error\"K\n" +
1152 "\aMuxData\x12,\n" +
1153 "\x12physical_stream_id\x18\x01 \x01(\x04R\x10physicalStreamId\x12\x12\n" +
1154 "\x04data\x18\x02 \x01(\fR\x04data\"8\n" +
1155 "\bMuxClose\x12,\n" +
1156 "\x12physical_stream_id\x18\x01 \x01(\x04R\x10physicalStreamId\"n\n" +
1157 "\bMuxReset\x12,\n" +
1158 "\x12physical_stream_id\x18\x01 \x01(\x04R\x10physicalStreamId\x124\n" +
1159 "\x05error\x18\x02 \x01(\v2\x1e.vev.wire.v1.BrokerErrorDetailR\x05error\"b\n" +
1160 "\x0fMuxWindowUpdate\x12,\n" +
1161 "\x12physical_stream_id\x18\x01 \x01(\x04R\x10physicalStreamId\x12!\n" +
1162 "\fcredit_bytes\x18\x02 \x01(\x04R\vcreditBytes\"\x9e\x02\n" +
1163 "\x11MuxClientEnvelope\x12+\n" +
1164 "\x04open\x18\xad\x02 \x01(\v2\x14.vev.wire.v1.MuxOpenH\x00R\x04open\x12+\n" +
1165 "\x04data\x18\xae\x02 \x01(\v2\x14.vev.wire.v1.MuxDataH\x00R\x04data\x12.\n" +
1166 "\x05close\x18\xaf\x02 \x01(\v2\x15.vev.wire.v1.MuxCloseH\x00R\x05close\x12.\n" +
1167 "\x05reset\x18\xb0\x02 \x01(\v2\x15.vev.wire.v1.MuxResetH\x00R\x05reset\x12D\n" +
1168 "\rwindow_update\x18\xb1\x02 \x01(\v2\x1c.vev.wire.v1.MuxWindowUpdateH\x00R\fwindowUpdateB\t\n" +
1169 "\apayload\"\xda\x02\n" +
1170 "\x11MuxServerEnvelope\x121\n" +
1171 "\x06opened\x18\x91\x03 \x01(\v2\x16.vev.wire.v1.MuxOpenedH\x00R\x06opened\x124\n" +
1172 "\arefused\x18\x92\x03 \x01(\v2\x17.vev.wire.v1.MuxRefusedH\x00R\arefused\x12+\n" +
1173 "\x04data\x18\x93\x03 \x01(\v2\x14.vev.wire.v1.MuxDataH\x00R\x04data\x12.\n" +
1174 "\x05close\x18\x94\x03 \x01(\v2\x15.vev.wire.v1.MuxCloseH\x00R\x05close\x12.\n" +
1175 "\x05reset\x18\x95\x03 \x01(\v2\x15.vev.wire.v1.MuxResetH\x00R\x05reset\x12D\n" +
1176 "\rwindow_update\x18\x96\x03 \x01(\v2\x1c.vev.wire.v1.MuxWindowUpdateH\x00R\fwindowUpdateB\t\n" +
1177 "\apayload\"\xa5\x03\n" +
1178 "\x12MuxPreambleRequest\x12\x14\n" +
1179 "\x05magic\x18\x01 \x01(\rR\x05magic\x12\x14\n" +
1180 "\x05epoch\x18\x02 \x01(\rR\x05epoch\x12\x18\n" +
1181 "\aversion\x18\x03 \x01(\rR\aversion\x12-\n" +
1182 "\x04role\x18\x04 \x01(\v2\x19.vev.wire.v1.PreambleRoleR\x04role\x12;\n" +
1183 "\x1amax_receive_envelope_bytes\x18\x05 \x01(\x04R\x17maxReceiveEnvelopeBytes\x12,\n" +
1184 "\x12stream_chunk_limit\x18\x06 \x01(\x04R\x10streamChunkLimit\x12\x1f\n" +
1185 "\vmax_streams\x18\a \x01(\x04R\n" +
1186 "maxStreams\x12.\n" +
1187 "\x13max_aggregate_bytes\x18\b \x01(\x04R\x11maxAggregateBytes\x12'\n" +
1188 "\x0fcapability_bits\x18\t \x01(\rR\x0ecapabilityBits\x125\n" +
1189 "\x06policy\x18\n" +
1190 " \x01(\v2\x1d.vev.wire.v1.BrokerWirePolicyR\x06policy\"\xe0\x04\n" +
1191 "\x13MuxPreambleResponse\x12\x14\n" +
1192 "\x05magic\x18\x01 \x01(\rR\x05magic\x12\x14\n" +
1193 "\x05epoch\x18\x02 \x01(\rR\x05epoch\x12\x18\n" +
1194 "\aversion\x18\x03 \x01(\rR\aversion\x12-\n" +
1195 "\x04role\x18\x04 \x01(\v2\x19.vev.wire.v1.PreambleRoleR\x04role\x12;\n" +
1196 "\x1amax_receive_envelope_bytes\x18\x05 \x01(\x04R\x17maxReceiveEnvelopeBytes\x12,\n" +
1197 "\x12stream_chunk_limit\x18\x06 \x01(\x04R\x10streamChunkLimit\x12\x1f\n" +
1198 "\vmax_streams\x18\a \x01(\x04R\n" +
1199 "maxStreams\x12.\n" +
1200 "\x13max_aggregate_bytes\x18\b \x01(\x04R\x11maxAggregateBytes\x12'\n" +
1201 "\x0fcapability_bits\x18\t \x01(\rR\x0ecapabilityBits\x12F\n" +
1202 "\x0faccepted_policy\x18\n" +
1203 " \x01(\v2\x1d.vev.wire.v1.BrokerWirePolicyR\x0eacceptedPolicy\x12\x1a\n" +
1204 "\baccepted\x18\v \x01(\bR\baccepted\x12@\n" +
1205 "\trejection\x18\f \x01(\v2\".vev.wire.v1.PreambleRejectionCodeR\trejection\x12'\n" +
1206 "\x0fdaemon_identity\x18\r \x01(\tR\x0edaemonIdentity\x12 \n" +
1207 "\vincarnation\x18\x0e \x01(\fR\vincarnationB-Z+github.com/bnema/vev/internal/protocol/wireb\x06proto3"
1208
1209var (
1210 file_multiplex_proto_rawDescOnce sync.Once
1211 file_multiplex_proto_rawDescData []byte
1212)
1213
1214func file_multiplex_proto_rawDescGZIP() []byte {
1215 file_multiplex_proto_rawDescOnce.Do(func() {
1216 file_multiplex_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_multiplex_proto_rawDesc), len(file_multiplex_proto_rawDesc)))
1217 })
1218 return file_multiplex_proto_rawDescData
1219}
1220
1221var file_multiplex_proto_msgTypes = make([]protoimpl.MessageInfo, 12)
1222var file_multiplex_proto_goTypes = []any{
1223 (*MuxStreamRef)(nil), // 0: vev.wire.v1.MuxStreamRef
1224 (*MuxOpen)(nil), // 1: vev.wire.v1.MuxOpen
1225 (*MuxOpened)(nil), // 2: vev.wire.v1.MuxOpened
1226 (*MuxRefused)(nil), // 3: vev.wire.v1.MuxRefused
1227 (*MuxData)(nil), // 4: vev.wire.v1.MuxData
1228 (*MuxClose)(nil), // 5: vev.wire.v1.MuxClose
1229 (*MuxReset)(nil), // 6: vev.wire.v1.MuxReset
1230 (*MuxWindowUpdate)(nil), // 7: vev.wire.v1.MuxWindowUpdate
1231 (*MuxClientEnvelope)(nil), // 8: vev.wire.v1.MuxClientEnvelope
1232 (*MuxServerEnvelope)(nil), // 9: vev.wire.v1.MuxServerEnvelope
1233 (*MuxPreambleRequest)(nil), // 10: vev.wire.v1.MuxPreambleRequest
1234 (*MuxPreambleResponse)(nil), // 11: vev.wire.v1.MuxPreambleResponse
1235 (*RemoteRegistration)(nil), // 12: vev.wire.v1.RemoteRegistration
1236 (*ExactTarget)(nil), // 13: vev.wire.v1.ExactTarget
1237 (*BrokerWirePolicy)(nil), // 14: vev.wire.v1.BrokerWirePolicy
1238 (*BrokerErrorDetail)(nil), // 15: vev.wire.v1.BrokerErrorDetail
1239 (*PreambleRole)(nil), // 16: vev.wire.v1.PreambleRole
1240 (*PreambleRejectionCode)(nil), // 17: vev.wire.v1.PreambleRejectionCode
1241}
1242var file_multiplex_proto_depIdxs = []int32{
1243 0, // 0: vev.wire.v1.MuxOpen.ref:type_name -> vev.wire.v1.MuxStreamRef
1244 12, // 1: vev.wire.v1.MuxOpen.registration:type_name -> vev.wire.v1.RemoteRegistration
1245 13, // 2: vev.wire.v1.MuxOpen.target:type_name -> vev.wire.v1.ExactTarget
1246 14, // 3: vev.wire.v1.MuxOpen.policy:type_name -> vev.wire.v1.BrokerWirePolicy
1247 0, // 4: vev.wire.v1.MuxOpened.ref:type_name -> vev.wire.v1.MuxStreamRef
1248 0, // 5: vev.wire.v1.MuxRefused.ref:type_name -> vev.wire.v1.MuxStreamRef
1249 15, // 6: vev.wire.v1.MuxRefused.error:type_name -> vev.wire.v1.BrokerErrorDetail
1250 15, // 7: vev.wire.v1.MuxReset.error:type_name -> vev.wire.v1.BrokerErrorDetail
1251 1, // 8: vev.wire.v1.MuxClientEnvelope.open:type_name -> vev.wire.v1.MuxOpen
1252 4, // 9: vev.wire.v1.MuxClientEnvelope.data:type_name -> vev.wire.v1.MuxData
1253 5, // 10: vev.wire.v1.MuxClientEnvelope.close:type_name -> vev.wire.v1.MuxClose
1254 6, // 11: vev.wire.v1.MuxClientEnvelope.reset:type_name -> vev.wire.v1.MuxReset
1255 7, // 12: vev.wire.v1.MuxClientEnvelope.window_update:type_name -> vev.wire.v1.MuxWindowUpdate
1256 2, // 13: vev.wire.v1.MuxServerEnvelope.opened:type_name -> vev.wire.v1.MuxOpened
1257 3, // 14: vev.wire.v1.MuxServerEnvelope.refused:type_name -> vev.wire.v1.MuxRefused
1258 4, // 15: vev.wire.v1.MuxServerEnvelope.data:type_name -> vev.wire.v1.MuxData
1259 5, // 16: vev.wire.v1.MuxServerEnvelope.close:type_name -> vev.wire.v1.MuxClose
1260 6, // 17: vev.wire.v1.MuxServerEnvelope.reset:type_name -> vev.wire.v1.MuxReset
1261 7, // 18: vev.wire.v1.MuxServerEnvelope.window_update:type_name -> vev.wire.v1.MuxWindowUpdate
1262 16, // 19: vev.wire.v1.MuxPreambleRequest.role:type_name -> vev.wire.v1.PreambleRole
1263 14, // 20: vev.wire.v1.MuxPreambleRequest.policy:type_name -> vev.wire.v1.BrokerWirePolicy
1264 16, // 21: vev.wire.v1.MuxPreambleResponse.role:type_name -> vev.wire.v1.PreambleRole
1265 14, // 22: vev.wire.v1.MuxPreambleResponse.accepted_policy:type_name -> vev.wire.v1.BrokerWirePolicy
1266 17, // 23: vev.wire.v1.MuxPreambleResponse.rejection:type_name -> vev.wire.v1.PreambleRejectionCode
1267 24, // [24:24] is the sub-list for method output_type
1268 24, // [24:24] is the sub-list for method input_type
1269 24, // [24:24] is the sub-list for extension type_name
1270 24, // [24:24] is the sub-list for extension extendee
1271 0, // [0:24] is the sub-list for field type_name
1272}
1273
1274func init() { file_multiplex_proto_init() }
1275func file_multiplex_proto_init() {
1276 if File_multiplex_proto != nil {
1277 return
1278 }
1279 file_broker_proto_init()
1280 file_common_proto_init()
1281 file_envelope_proto_init()
1282 file_multiplex_proto_msgTypes[8].OneofWrappers = []any{
1283 (*MuxClientEnvelope_Open)(nil),
1284 (*MuxClientEnvelope_Data)(nil),
1285 (*MuxClientEnvelope_Close)(nil),
1286 (*MuxClientEnvelope_Reset_)(nil),
1287 (*MuxClientEnvelope_WindowUpdate)(nil),
1288 }
1289 file_multiplex_proto_msgTypes[9].OneofWrappers = []any{
1290 (*MuxServerEnvelope_Opened)(nil),
1291 (*MuxServerEnvelope_Refused)(nil),
1292 (*MuxServerEnvelope_Data)(nil),
1293 (*MuxServerEnvelope_Close)(nil),
1294 (*MuxServerEnvelope_Reset_)(nil),
1295 (*MuxServerEnvelope_WindowUpdate)(nil),
1296 }
1297 type x struct{}
1298 out := protoimpl.TypeBuilder{
1299 File: protoimpl.DescBuilder{
1300 GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
1301 RawDescriptor: unsafe.Slice(unsafe.StringData(file_multiplex_proto_rawDesc), len(file_multiplex_proto_rawDesc)),
1302 NumEnums: 0,
1303 NumMessages: 12,
1304 NumExtensions: 0,
1305 NumServices: 0,
1306 },
1307 GoTypes: file_multiplex_proto_goTypes,
1308 DependencyIndexes: file_multiplex_proto_depIdxs,
1309 MessageInfos: file_multiplex_proto_msgTypes,
1310 }.Build()
1311 File_multiplex_proto = out.File
1312 file_multiplex_proto_goTypes = nil
1313 file_multiplex_proto_depIdxs = nil
1314}