diff --git a/api/clock/v1/message.pb.go b/api/clock/v1/message.pb.go index 989f124ea36..ff11f82c1a8 100644 --- a/api/clock/v1/message.pb.go +++ b/api/clock/v1/message.pb.go @@ -108,8 +108,76 @@ func (m *VectorClock) GetClusterId() int64 { return 0 } +// A Hybrid Logical Clock timestamp. +// Guarantees strict total ordering for conflict resolution purposes. +type HybridLogicalClock struct { + // Wall clock - A single time source MUST guarantee that 2 consecutive timestamps are monotonically non-decreasing. + // e.g. by storing the last wall clock and returning max(gettimeofday(), lastWallClock). + WallClock int64 `protobuf:"varint,1,opt,name=wall_clock,json=wallClock,proto3" json:"wall_clock,omitempty"` + // Incremental sequence that is reset every time the system's wallclock moves forward. + // Ensures the clock generates monotonically increasing timestamps. + Version int32 `protobuf:"varint,2,opt,name=version,proto3" json:"version,omitempty"` + // The cluster version ID as described in the XDC docs - used as a tie breaker. + // See: https://github.com/uber/cadence/blob/master/docs/design/2290-cadence-ndc.md + ClusterId int64 `protobuf:"varint,3,opt,name=cluster_id,json=clusterId,proto3" json:"cluster_id,omitempty"` +} + +func (m *HybridLogicalClock) Reset() { *m = HybridLogicalClock{} } +func (*HybridLogicalClock) ProtoMessage() {} +func (*HybridLogicalClock) Descriptor() ([]byte, []int) { + return fileDescriptor_86d20c4676353367, []int{1} +} +func (m *HybridLogicalClock) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *HybridLogicalClock) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_HybridLogicalClock.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *HybridLogicalClock) XXX_Merge(src proto.Message) { + xxx_messageInfo_HybridLogicalClock.Merge(m, src) +} +func (m *HybridLogicalClock) XXX_Size() int { + return m.Size() +} +func (m *HybridLogicalClock) XXX_DiscardUnknown() { + xxx_messageInfo_HybridLogicalClock.DiscardUnknown(m) +} + +var xxx_messageInfo_HybridLogicalClock proto.InternalMessageInfo + +func (m *HybridLogicalClock) GetWallClock() int64 { + if m != nil { + return m.WallClock + } + return 0 +} + +func (m *HybridLogicalClock) GetVersion() int32 { + if m != nil { + return m.Version + } + return 0 +} + +func (m *HybridLogicalClock) GetClusterId() int64 { + if m != nil { + return m.ClusterId + } + return 0 +} + func init() { proto.RegisterType((*VectorClock)(nil), "temporal.server.api.clock.v1.VectorClock") + proto.RegisterType((*HybridLogicalClock)(nil), "temporal.server.api.clock.v1.HybridLogicalClock") } func init() { @@ -117,22 +185,25 @@ func init() { } var fileDescriptor_86d20c4676353367 = []byte{ - // 234 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0xd2, 0x2a, 0x49, 0xcd, 0x2d, - 0xc8, 0x2f, 0x4a, 0xcc, 0xd1, 0x2f, 0x4e, 0x2d, 0x2a, 0x4b, 0x2d, 0xd2, 0x4f, 0x2c, 0xc8, 0xd4, - 0x4f, 0xce, 0xc9, 0x4f, 0xce, 0xd6, 0x2f, 0x33, 0xd4, 0xcf, 0x4d, 0x2d, 0x2e, 0x4e, 0x4c, 0x4f, - 0xd5, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x92, 0x81, 0xa9, 0xd5, 0x83, 0xa8, 0xd5, 0x4b, 0x2c, - 0xc8, 0xd4, 0x03, 0xab, 0xd5, 0x2b, 0x33, 0x54, 0x8a, 0xe5, 0xe2, 0x0e, 0x4b, 0x4d, 0x2e, 0xc9, - 0x2f, 0x72, 0x06, 0x89, 0x08, 0x49, 0x72, 0x71, 0x14, 0x67, 0x24, 0x16, 0xa5, 0xc4, 0x67, 0xa6, - 0x48, 0x30, 0x2a, 0x30, 0x6a, 0xb0, 0x06, 0xb1, 0x83, 0xf9, 0x9e, 0x29, 0x42, 0x22, 0x5c, 0xac, - 0x60, 0x5d, 0x12, 0x4c, 0x0a, 0x8c, 0x1a, 0xcc, 0x41, 0x10, 0x8e, 0x90, 0x2c, 0x17, 0x57, 0x72, - 0x4e, 0x69, 0x71, 0x49, 0x6a, 0x11, 0x48, 0x0b, 0x33, 0x58, 0x8a, 0x13, 0x2a, 0xe2, 0x99, 0xe2, - 0x14, 0x77, 0xe1, 0xa1, 0x1c, 0xc3, 0x8d, 0x87, 0x72, 0x0c, 0x1f, 0x1e, 0xca, 0x31, 0x36, 0x3c, - 0x92, 0x63, 0x5c, 0xf1, 0x48, 0x8e, 0xf1, 0xc4, 0x23, 0x39, 0xc6, 0x0b, 0x8f, 0xe4, 0x18, 0x1f, - 0x3c, 0x92, 0x63, 0x7c, 0xf1, 0x48, 0x8e, 0xe1, 0xc3, 0x23, 0x39, 0xc6, 0x09, 0x8f, 0xe5, 0x18, - 0x2e, 0x3c, 0x96, 0x63, 0xb8, 0xf1, 0x58, 0x8e, 0x21, 0x4a, 0x23, 0x3d, 0x5f, 0x0f, 0xee, 0xea, - 0xcc, 0x7c, 0x6c, 0x9e, 0xb4, 0x06, 0x33, 0x92, 0xd8, 0xc0, 0x7e, 0x34, 0x06, 0x04, 0x00, 0x00, - 0xff, 0xff, 0xc4, 0x11, 0xe0, 0xe1, 0x11, 0x01, 0x00, 0x00, + // 284 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x84, 0x90, 0xb1, 0x4e, 0xc3, 0x30, + 0x18, 0x84, 0xfd, 0x53, 0x95, 0x82, 0xd9, 0x22, 0x86, 0x22, 0xc1, 0xaf, 0xaa, 0x53, 0xc4, 0xe0, + 0xa8, 0x62, 0x64, 0xa3, 0x0b, 0x95, 0x98, 0x32, 0x30, 0x20, 0x41, 0xe5, 0x26, 0x56, 0xb0, 0x70, + 0x71, 0x64, 0x87, 0x20, 0x36, 0x1e, 0x81, 0xc7, 0xe0, 0x51, 0x18, 0x33, 0x76, 0x24, 0xce, 0xc2, + 0xd8, 0x47, 0x40, 0x71, 0x08, 0x13, 0x12, 0x9b, 0xef, 0xfe, 0xfb, 0x7c, 0xd2, 0xd1, 0xd3, 0x42, + 0xac, 0x73, 0x6d, 0xb8, 0x8a, 0xac, 0x30, 0xa5, 0x30, 0x11, 0xcf, 0x65, 0x94, 0x28, 0x9d, 0x3c, + 0x44, 0xe5, 0x2c, 0x5a, 0x0b, 0x6b, 0x79, 0x26, 0x58, 0x6e, 0x74, 0xa1, 0x83, 0xe3, 0x3e, 0xcb, + 0xba, 0x2c, 0xe3, 0xb9, 0x64, 0x3e, 0xcb, 0xca, 0xd9, 0xf4, 0x96, 0x1e, 0x5c, 0x8b, 0xa4, 0xd0, + 0x66, 0xde, 0x3a, 0xc1, 0x11, 0xdd, 0xb3, 0xf7, 0xdc, 0xa4, 0x4b, 0x99, 0x8e, 0x61, 0x02, 0xe1, + 0x30, 0x1e, 0x79, 0xbd, 0x48, 0x83, 0x43, 0x3a, 0xf4, 0xd4, 0x78, 0x67, 0x02, 0xe1, 0x20, 0xee, + 0x44, 0x70, 0x42, 0x69, 0xa2, 0x9e, 0x6c, 0x21, 0x4c, 0x8b, 0x0c, 0xfc, 0x69, 0xff, 0xc7, 0x59, + 0xa4, 0x53, 0x45, 0x83, 0xcb, 0x97, 0x95, 0x91, 0xe9, 0x95, 0xce, 0x64, 0xc2, 0xd5, 0xbc, 0x87, + 0x9e, 0xb9, 0x52, 0xcb, 0xee, 0x3f, 0xe8, 0xa0, 0xd6, 0xe9, 0xce, 0x63, 0x3a, 0x2a, 0x85, 0xb1, + 0x52, 0x3f, 0xfa, 0xae, 0x61, 0xdc, 0xcb, 0x7f, 0xda, 0x2e, 0xee, 0xaa, 0x1a, 0xc9, 0xa6, 0x46, + 0xb2, 0xad, 0x11, 0x5e, 0x1d, 0xc2, 0xbb, 0x43, 0xf8, 0x70, 0x08, 0x95, 0x43, 0xf8, 0x74, 0x08, + 0x5f, 0x0e, 0xc9, 0xd6, 0x21, 0xbc, 0x35, 0x48, 0xaa, 0x06, 0xc9, 0xa6, 0x41, 0x72, 0x13, 0x66, + 0x9a, 0xfd, 0x6e, 0x24, 0xf5, 0x5f, 0x93, 0x9e, 0xfb, 0xc7, 0x6a, 0xd7, 0x2f, 0x7a, 0xf6, 0x1d, + 0x00, 0x00, 0xff, 0xff, 0xfe, 0x8b, 0xe4, 0xcb, 0x7f, 0x01, 0x00, 0x00, } func (this *VectorClock) Equal(that interface{}) bool { @@ -165,6 +236,36 @@ func (this *VectorClock) Equal(that interface{}) bool { } return true } +func (this *HybridLogicalClock) Equal(that interface{}) bool { + if that == nil { + return this == nil + } + + that1, ok := that.(*HybridLogicalClock) + if !ok { + that2, ok := that.(HybridLogicalClock) + if ok { + that1 = &that2 + } else { + return false + } + } + if that1 == nil { + return this == nil + } else if this == nil { + return false + } + if this.WallClock != that1.WallClock { + return false + } + if this.Version != that1.Version { + return false + } + if this.ClusterId != that1.ClusterId { + return false + } + return true +} func (this *VectorClock) GoString() string { if this == nil { return "nil" @@ -177,6 +278,18 @@ func (this *VectorClock) GoString() string { s = append(s, "}") return strings.Join(s, "") } +func (this *HybridLogicalClock) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 7) + s = append(s, "&clock.HybridLogicalClock{") + s = append(s, "WallClock: "+fmt.Sprintf("%#v", this.WallClock)+",\n") + s = append(s, "Version: "+fmt.Sprintf("%#v", this.Version)+",\n") + s = append(s, "ClusterId: "+fmt.Sprintf("%#v", this.ClusterId)+",\n") + s = append(s, "}") + return strings.Join(s, "") +} func valueToGoStringMessage(v interface{}, typ string) string { rv := reflect.ValueOf(v) if rv.IsNil() { @@ -223,6 +336,44 @@ func (m *VectorClock) MarshalToSizedBuffer(dAtA []byte) (int, error) { return len(dAtA) - i, nil } +func (m *HybridLogicalClock) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *HybridLogicalClock) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *HybridLogicalClock) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.ClusterId != 0 { + i = encodeVarintMessage(dAtA, i, uint64(m.ClusterId)) + i-- + dAtA[i] = 0x18 + } + if m.Version != 0 { + i = encodeVarintMessage(dAtA, i, uint64(m.Version)) + i-- + dAtA[i] = 0x10 + } + if m.WallClock != 0 { + i = encodeVarintMessage(dAtA, i, uint64(m.WallClock)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + func encodeVarintMessage(dAtA []byte, offset int, v uint64) int { offset -= sovMessage(v) base := offset @@ -252,6 +403,24 @@ func (m *VectorClock) Size() (n int) { return n } +func (m *HybridLogicalClock) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.WallClock != 0 { + n += 1 + sovMessage(uint64(m.WallClock)) + } + if m.Version != 0 { + n += 1 + sovMessage(uint64(m.Version)) + } + if m.ClusterId != 0 { + n += 1 + sovMessage(uint64(m.ClusterId)) + } + return n +} + func sovMessage(x uint64) (n int) { return (math_bits.Len64(x|1) + 6) / 7 } @@ -270,6 +439,18 @@ func (this *VectorClock) String() string { }, "") return s } +func (this *HybridLogicalClock) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&HybridLogicalClock{`, + `WallClock:` + fmt.Sprintf("%v", this.WallClock) + `,`, + `Version:` + fmt.Sprintf("%v", this.Version) + `,`, + `ClusterId:` + fmt.Sprintf("%v", this.ClusterId) + `,`, + `}`, + }, "") + return s +} func valueToStringMessage(v interface{}) string { rv := reflect.ValueOf(v) if rv.IsNil() { @@ -388,6 +569,116 @@ func (m *VectorClock) Unmarshal(dAtA []byte) error { } return nil } +func (m *HybridLogicalClock) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMessage + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: HybridLogicalClock: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: HybridLogicalClock: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field WallClock", wireType) + } + m.WallClock = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMessage + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.WallClock |= int64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType) + } + m.Version = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMessage + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Version |= int32(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ClusterId", wireType) + } + m.ClusterId = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMessage + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.ClusterId |= int64(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipMessage(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthMessage + } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthMessage + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} func skipMessage(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 diff --git a/api/matchingservice/v1/request_response.pb.go b/api/matchingservice/v1/request_response.pb.go index 32746f55960..946efc3d467 100644 --- a/api/matchingservice/v1/request_response.pb.go +++ b/api/matchingservice/v1/request_response.pb.go @@ -1535,25 +1535,25 @@ func (m *GetWorkerBuildIdCompatibilityResponse) GetResponse() *v1.GetWorkerBuild return nil } -type InvalidateTaskQueueMetadataRequest struct { +type InvalidateTaskQueueUserDataRequest struct { NamespaceId string `protobuf:"bytes,1,opt,name=namespace_id,json=namespaceId,proto3" json:"namespace_id,omitempty"` TaskQueue string `protobuf:"bytes,2,opt,name=task_queue,json=taskQueue,proto3" json:"task_queue,omitempty"` TaskQueueType v18.TaskQueueType `protobuf:"varint,3,opt,name=task_queue_type,json=taskQueueType,proto3,enum=temporal.api.enums.v1.TaskQueueType" json:"task_queue_type,omitempty"` - // The task queue versioning data should be invalidated and replaced with this data, if set. - VersioningData *v19.VersioningData `protobuf:"bytes,4,opt,name=versioning_data,json=versioningData,proto3" json:"versioning_data,omitempty"` + // The partition's cached user data should be invalidated and replaced with this data, if set. + UserData *v19.VersionedTaskQueueUserData `protobuf:"bytes,4,opt,name=user_data,json=userData,proto3" json:"user_data,omitempty"` } -func (m *InvalidateTaskQueueMetadataRequest) Reset() { *m = InvalidateTaskQueueMetadataRequest{} } -func (*InvalidateTaskQueueMetadataRequest) ProtoMessage() {} -func (*InvalidateTaskQueueMetadataRequest) Descriptor() ([]byte, []int) { +func (m *InvalidateTaskQueueUserDataRequest) Reset() { *m = InvalidateTaskQueueUserDataRequest{} } +func (*InvalidateTaskQueueUserDataRequest) ProtoMessage() {} +func (*InvalidateTaskQueueUserDataRequest) Descriptor() ([]byte, []int) { return fileDescriptor_a429a3813476c583, []int{22} } -func (m *InvalidateTaskQueueMetadataRequest) XXX_Unmarshal(b []byte) error { +func (m *InvalidateTaskQueueUserDataRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } -func (m *InvalidateTaskQueueMetadataRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { +func (m *InvalidateTaskQueueUserDataRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { - return xxx_messageInfo_InvalidateTaskQueueMetadataRequest.Marshal(b, m, deterministic) + return xxx_messageInfo_InvalidateTaskQueueUserDataRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) @@ -1563,60 +1563,60 @@ func (m *InvalidateTaskQueueMetadataRequest) XXX_Marshal(b []byte, deterministic return b[:n], nil } } -func (m *InvalidateTaskQueueMetadataRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_InvalidateTaskQueueMetadataRequest.Merge(m, src) +func (m *InvalidateTaskQueueUserDataRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_InvalidateTaskQueueUserDataRequest.Merge(m, src) } -func (m *InvalidateTaskQueueMetadataRequest) XXX_Size() int { +func (m *InvalidateTaskQueueUserDataRequest) XXX_Size() int { return m.Size() } -func (m *InvalidateTaskQueueMetadataRequest) XXX_DiscardUnknown() { - xxx_messageInfo_InvalidateTaskQueueMetadataRequest.DiscardUnknown(m) +func (m *InvalidateTaskQueueUserDataRequest) XXX_DiscardUnknown() { + xxx_messageInfo_InvalidateTaskQueueUserDataRequest.DiscardUnknown(m) } -var xxx_messageInfo_InvalidateTaskQueueMetadataRequest proto.InternalMessageInfo +var xxx_messageInfo_InvalidateTaskQueueUserDataRequest proto.InternalMessageInfo -func (m *InvalidateTaskQueueMetadataRequest) GetNamespaceId() string { +func (m *InvalidateTaskQueueUserDataRequest) GetNamespaceId() string { if m != nil { return m.NamespaceId } return "" } -func (m *InvalidateTaskQueueMetadataRequest) GetTaskQueue() string { +func (m *InvalidateTaskQueueUserDataRequest) GetTaskQueue() string { if m != nil { return m.TaskQueue } return "" } -func (m *InvalidateTaskQueueMetadataRequest) GetTaskQueueType() v18.TaskQueueType { +func (m *InvalidateTaskQueueUserDataRequest) GetTaskQueueType() v18.TaskQueueType { if m != nil { return m.TaskQueueType } return v18.TASK_QUEUE_TYPE_UNSPECIFIED } -func (m *InvalidateTaskQueueMetadataRequest) GetVersioningData() *v19.VersioningData { +func (m *InvalidateTaskQueueUserDataRequest) GetUserData() *v19.VersionedTaskQueueUserData { if m != nil { - return m.VersioningData + return m.UserData } return nil } -type InvalidateTaskQueueMetadataResponse struct { +type InvalidateTaskQueueUserDataResponse struct { } -func (m *InvalidateTaskQueueMetadataResponse) Reset() { *m = InvalidateTaskQueueMetadataResponse{} } -func (*InvalidateTaskQueueMetadataResponse) ProtoMessage() {} -func (*InvalidateTaskQueueMetadataResponse) Descriptor() ([]byte, []int) { +func (m *InvalidateTaskQueueUserDataResponse) Reset() { *m = InvalidateTaskQueueUserDataResponse{} } +func (*InvalidateTaskQueueUserDataResponse) ProtoMessage() {} +func (*InvalidateTaskQueueUserDataResponse) Descriptor() ([]byte, []int) { return fileDescriptor_a429a3813476c583, []int{23} } -func (m *InvalidateTaskQueueMetadataResponse) XXX_Unmarshal(b []byte) error { +func (m *InvalidateTaskQueueUserDataResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } -func (m *InvalidateTaskQueueMetadataResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { +func (m *InvalidateTaskQueueUserDataResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { - return xxx_messageInfo_InvalidateTaskQueueMetadataResponse.Marshal(b, m, deterministic) + return xxx_messageInfo_InvalidateTaskQueueUserDataResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) @@ -1626,41 +1626,40 @@ func (m *InvalidateTaskQueueMetadataResponse) XXX_Marshal(b []byte, deterministi return b[:n], nil } } -func (m *InvalidateTaskQueueMetadataResponse) XXX_Merge(src proto.Message) { - xxx_messageInfo_InvalidateTaskQueueMetadataResponse.Merge(m, src) +func (m *InvalidateTaskQueueUserDataResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_InvalidateTaskQueueUserDataResponse.Merge(m, src) } -func (m *InvalidateTaskQueueMetadataResponse) XXX_Size() int { +func (m *InvalidateTaskQueueUserDataResponse) XXX_Size() int { return m.Size() } -func (m *InvalidateTaskQueueMetadataResponse) XXX_DiscardUnknown() { - xxx_messageInfo_InvalidateTaskQueueMetadataResponse.DiscardUnknown(m) +func (m *InvalidateTaskQueueUserDataResponse) XXX_DiscardUnknown() { + xxx_messageInfo_InvalidateTaskQueueUserDataResponse.DiscardUnknown(m) } -var xxx_messageInfo_InvalidateTaskQueueMetadataResponse proto.InternalMessageInfo +var xxx_messageInfo_InvalidateTaskQueueUserDataResponse proto.InternalMessageInfo -type GetTaskQueueMetadataRequest struct { +type GetTaskQueueUserDataRequest struct { NamespaceId string `protobuf:"bytes,1,opt,name=namespace_id,json=namespaceId,proto3" json:"namespace_id,omitempty"` // The task queue to fetch data from. Is always considered as a workflow queue, since root // workflow queues own the metadata. TaskQueue string `protobuf:"bytes,2,opt,name=task_queue,json=taskQueue,proto3" json:"task_queue,omitempty"` - // If set nonempty, the requester wants the latest versioning data. The value must be the hash - // (using farm hash Fingerprint64) of the latest versioning data. If the requester has no data, - // it can use any invalid value (ex: [0]). - // If the data is up to date, no value will be returned. - WantVersioningDataCurhash []byte `protobuf:"bytes,3,opt,name=want_versioning_data_curhash,json=wantVersioningDataCurhash,proto3" json:"want_versioning_data_curhash,omitempty"` + // The value of the last known user data version. + // If the requester has no data, it should set this to 0. + // This value must not be set to a negative number (note that our linter suggests avoiding uint64). + LastKnownUserDataVersion int64 `protobuf:"varint,3,opt,name=last_known_user_data_version,json=lastKnownUserDataVersion,proto3" json:"last_known_user_data_version,omitempty"` } -func (m *GetTaskQueueMetadataRequest) Reset() { *m = GetTaskQueueMetadataRequest{} } -func (*GetTaskQueueMetadataRequest) ProtoMessage() {} -func (*GetTaskQueueMetadataRequest) Descriptor() ([]byte, []int) { +func (m *GetTaskQueueUserDataRequest) Reset() { *m = GetTaskQueueUserDataRequest{} } +func (*GetTaskQueueUserDataRequest) ProtoMessage() {} +func (*GetTaskQueueUserDataRequest) Descriptor() ([]byte, []int) { return fileDescriptor_a429a3813476c583, []int{24} } -func (m *GetTaskQueueMetadataRequest) XXX_Unmarshal(b []byte) error { +func (m *GetTaskQueueUserDataRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } -func (m *GetTaskQueueMetadataRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { +func (m *GetTaskQueueUserDataRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { - return xxx_messageInfo_GetTaskQueueMetadataRequest.Marshal(b, m, deterministic) + return xxx_messageInfo_GetTaskQueueUserDataRequest.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) @@ -1670,57 +1669,58 @@ func (m *GetTaskQueueMetadataRequest) XXX_Marshal(b []byte, deterministic bool) return b[:n], nil } } -func (m *GetTaskQueueMetadataRequest) XXX_Merge(src proto.Message) { - xxx_messageInfo_GetTaskQueueMetadataRequest.Merge(m, src) +func (m *GetTaskQueueUserDataRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_GetTaskQueueUserDataRequest.Merge(m, src) } -func (m *GetTaskQueueMetadataRequest) XXX_Size() int { +func (m *GetTaskQueueUserDataRequest) XXX_Size() int { return m.Size() } -func (m *GetTaskQueueMetadataRequest) XXX_DiscardUnknown() { - xxx_messageInfo_GetTaskQueueMetadataRequest.DiscardUnknown(m) +func (m *GetTaskQueueUserDataRequest) XXX_DiscardUnknown() { + xxx_messageInfo_GetTaskQueueUserDataRequest.DiscardUnknown(m) } -var xxx_messageInfo_GetTaskQueueMetadataRequest proto.InternalMessageInfo +var xxx_messageInfo_GetTaskQueueUserDataRequest proto.InternalMessageInfo -func (m *GetTaskQueueMetadataRequest) GetNamespaceId() string { +func (m *GetTaskQueueUserDataRequest) GetNamespaceId() string { if m != nil { return m.NamespaceId } return "" } -func (m *GetTaskQueueMetadataRequest) GetTaskQueue() string { +func (m *GetTaskQueueUserDataRequest) GetTaskQueue() string { if m != nil { return m.TaskQueue } return "" } -func (m *GetTaskQueueMetadataRequest) GetWantVersioningDataCurhash() []byte { +func (m *GetTaskQueueUserDataRequest) GetLastKnownUserDataVersion() int64 { if m != nil { - return m.WantVersioningDataCurhash + return m.LastKnownUserDataVersion } - return nil + return 0 } -type GetTaskQueueMetadataResponse struct { - // Types that are valid to be assigned to VersioningDataResp: - // *GetTaskQueueMetadataResponse_VersioningData - // *GetTaskQueueMetadataResponse_MatchedReqHash - VersioningDataResp isGetTaskQueueMetadataResponse_VersioningDataResp `protobuf_oneof:"versioning_data_resp"` +type GetTaskQueueUserDataResponse struct { + // Whether this task queue has any stored user data + TaskQueueHasUserData bool `protobuf:"varint,1,opt,name=task_queue_has_user_data,json=taskQueueHasUserData,proto3" json:"task_queue_has_user_data,omitempty"` + // Versioned user data, set if the task queue has user data and the request's last_known_user_data_version is less + // than the version cached in the root partition. + UserData *v19.VersionedTaskQueueUserData `protobuf:"bytes,2,opt,name=user_data,json=userData,proto3" json:"user_data,omitempty"` } -func (m *GetTaskQueueMetadataResponse) Reset() { *m = GetTaskQueueMetadataResponse{} } -func (*GetTaskQueueMetadataResponse) ProtoMessage() {} -func (*GetTaskQueueMetadataResponse) Descriptor() ([]byte, []int) { +func (m *GetTaskQueueUserDataResponse) Reset() { *m = GetTaskQueueUserDataResponse{} } +func (*GetTaskQueueUserDataResponse) ProtoMessage() {} +func (*GetTaskQueueUserDataResponse) Descriptor() ([]byte, []int) { return fileDescriptor_a429a3813476c583, []int{25} } -func (m *GetTaskQueueMetadataResponse) XXX_Unmarshal(b []byte) error { +func (m *GetTaskQueueUserDataResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } -func (m *GetTaskQueueMetadataResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { +func (m *GetTaskQueueUserDataResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { - return xxx_messageInfo_GetTaskQueueMetadataResponse.Marshal(b, m, deterministic) + return xxx_messageInfo_GetTaskQueueUserDataResponse.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) @@ -1730,64 +1730,30 @@ func (m *GetTaskQueueMetadataResponse) XXX_Marshal(b []byte, deterministic bool) return b[:n], nil } } -func (m *GetTaskQueueMetadataResponse) XXX_Merge(src proto.Message) { - xxx_messageInfo_GetTaskQueueMetadataResponse.Merge(m, src) +func (m *GetTaskQueueUserDataResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_GetTaskQueueUserDataResponse.Merge(m, src) } -func (m *GetTaskQueueMetadataResponse) XXX_Size() int { +func (m *GetTaskQueueUserDataResponse) XXX_Size() int { return m.Size() } -func (m *GetTaskQueueMetadataResponse) XXX_DiscardUnknown() { - xxx_messageInfo_GetTaskQueueMetadataResponse.DiscardUnknown(m) -} - -var xxx_messageInfo_GetTaskQueueMetadataResponse proto.InternalMessageInfo - -type isGetTaskQueueMetadataResponse_VersioningDataResp interface { - isGetTaskQueueMetadataResponse_VersioningDataResp() - Equal(interface{}) bool - MarshalTo([]byte) (int, error) - Size() int -} - -type GetTaskQueueMetadataResponse_VersioningData struct { - VersioningData *v19.VersioningData `protobuf:"bytes,1,opt,name=versioning_data,json=versioningData,proto3,oneof" json:"versioning_data,omitempty"` -} -type GetTaskQueueMetadataResponse_MatchedReqHash struct { - MatchedReqHash bool `protobuf:"varint,2,opt,name=matched_req_hash,json=matchedReqHash,proto3,oneof" json:"matched_req_hash,omitempty"` +func (m *GetTaskQueueUserDataResponse) XXX_DiscardUnknown() { + xxx_messageInfo_GetTaskQueueUserDataResponse.DiscardUnknown(m) } -func (*GetTaskQueueMetadataResponse_VersioningData) isGetTaskQueueMetadataResponse_VersioningDataResp() { -} -func (*GetTaskQueueMetadataResponse_MatchedReqHash) isGetTaskQueueMetadataResponse_VersioningDataResp() { -} +var xxx_messageInfo_GetTaskQueueUserDataResponse proto.InternalMessageInfo -func (m *GetTaskQueueMetadataResponse) GetVersioningDataResp() isGetTaskQueueMetadataResponse_VersioningDataResp { +func (m *GetTaskQueueUserDataResponse) GetTaskQueueHasUserData() bool { if m != nil { - return m.VersioningDataResp - } - return nil -} - -func (m *GetTaskQueueMetadataResponse) GetVersioningData() *v19.VersioningData { - if x, ok := m.GetVersioningDataResp().(*GetTaskQueueMetadataResponse_VersioningData); ok { - return x.VersioningData - } - return nil -} - -func (m *GetTaskQueueMetadataResponse) GetMatchedReqHash() bool { - if x, ok := m.GetVersioningDataResp().(*GetTaskQueueMetadataResponse_MatchedReqHash); ok { - return x.MatchedReqHash + return m.TaskQueueHasUserData } return false } -// XXX_OneofWrappers is for the internal use of the proto package. -func (*GetTaskQueueMetadataResponse) XXX_OneofWrappers() []interface{} { - return []interface{}{ - (*GetTaskQueueMetadataResponse_VersioningData)(nil), - (*GetTaskQueueMetadataResponse_MatchedReqHash)(nil), +func (m *GetTaskQueueUserDataResponse) GetUserData() *v19.VersionedTaskQueueUserData { + if m != nil { + return m.UserData } + return nil } func init() { @@ -1814,10 +1780,10 @@ func init() { proto.RegisterType((*UpdateWorkerBuildIdCompatibilityResponse)(nil), "temporal.server.api.matchingservice.v1.UpdateWorkerBuildIdCompatibilityResponse") proto.RegisterType((*GetWorkerBuildIdCompatibilityRequest)(nil), "temporal.server.api.matchingservice.v1.GetWorkerBuildIdCompatibilityRequest") proto.RegisterType((*GetWorkerBuildIdCompatibilityResponse)(nil), "temporal.server.api.matchingservice.v1.GetWorkerBuildIdCompatibilityResponse") - proto.RegisterType((*InvalidateTaskQueueMetadataRequest)(nil), "temporal.server.api.matchingservice.v1.InvalidateTaskQueueMetadataRequest") - proto.RegisterType((*InvalidateTaskQueueMetadataResponse)(nil), "temporal.server.api.matchingservice.v1.InvalidateTaskQueueMetadataResponse") - proto.RegisterType((*GetTaskQueueMetadataRequest)(nil), "temporal.server.api.matchingservice.v1.GetTaskQueueMetadataRequest") - proto.RegisterType((*GetTaskQueueMetadataResponse)(nil), "temporal.server.api.matchingservice.v1.GetTaskQueueMetadataResponse") + proto.RegisterType((*InvalidateTaskQueueUserDataRequest)(nil), "temporal.server.api.matchingservice.v1.InvalidateTaskQueueUserDataRequest") + proto.RegisterType((*InvalidateTaskQueueUserDataResponse)(nil), "temporal.server.api.matchingservice.v1.InvalidateTaskQueueUserDataResponse") + proto.RegisterType((*GetTaskQueueUserDataRequest)(nil), "temporal.server.api.matchingservice.v1.GetTaskQueueUserDataRequest") + proto.RegisterType((*GetTaskQueueUserDataResponse)(nil), "temporal.server.api.matchingservice.v1.GetTaskQueueUserDataResponse") } func init() { @@ -1825,136 +1791,135 @@ func init() { } var fileDescriptor_a429a3813476c583 = []byte{ - // 2052 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x59, 0xcd, 0x73, 0x1b, 0x49, - 0x15, 0xf7, 0xc8, 0xb2, 0x2d, 0x3d, 0xc9, 0x8e, 0x3c, 0xec, 0x3a, 0xb2, 0x63, 0xcb, 0x8e, 0x92, - 0x6c, 0x9c, 0x54, 0x90, 0x2b, 0xa6, 0x36, 0xb5, 0xbb, 0x90, 0x0a, 0xb1, 0x63, 0x62, 0x2f, 0x09, - 0x38, 0x13, 0xb3, 0x50, 0x01, 0x6a, 0xb6, 0x35, 0xd3, 0x96, 0x06, 0x8f, 0xa6, 0xe5, 0xe9, 0x1e, - 0x79, 0xcd, 0x09, 0x0e, 0x14, 0x07, 0x2e, 0x4b, 0x71, 0x81, 0xe2, 0xc2, 0x89, 0x02, 0x4e, 0x1c, - 0xf8, 0x07, 0xb8, 0x71, 0xe0, 0x90, 0xe3, 0xde, 0x20, 0xce, 0x85, 0x2a, 0x2e, 0xcb, 0x7f, 0x40, - 0xf5, 0xc7, 0x8c, 0x34, 0xa3, 0xb1, 0x25, 0x2b, 0x59, 0xc2, 0x4d, 0xf3, 0x3e, 0x7e, 0xfd, 0xde, - 0xeb, 0xf7, 0x35, 0x23, 0xb8, 0xcb, 0x70, 0xab, 0x4d, 0x7c, 0xe4, 0xae, 0x51, 0xec, 0x77, 0xb0, - 0xbf, 0x86, 0xda, 0xce, 0x5a, 0x0b, 0x31, 0xab, 0xe9, 0x78, 0x0d, 0x4e, 0x72, 0x2c, 0xbc, 0xd6, - 0xb9, 0xbd, 0xe6, 0xe3, 0xc3, 0x00, 0x53, 0x66, 0xfa, 0x98, 0xb6, 0x89, 0x47, 0x71, 0xad, 0xed, - 0x13, 0x46, 0xf4, 0x77, 0x42, 0xf5, 0x9a, 0x54, 0xaf, 0xa1, 0xb6, 0x53, 0x4b, 0xa8, 0xd7, 0x3a, - 0xb7, 0x17, 0x2a, 0x0d, 0x42, 0x1a, 0x2e, 0x5e, 0x13, 0x5a, 0xf5, 0x60, 0x7f, 0xcd, 0x0e, 0x7c, - 0xc4, 0x1c, 0xe2, 0x49, 0x9c, 0x85, 0xe5, 0x24, 0x9f, 0x39, 0x2d, 0x4c, 0x19, 0x6a, 0xb5, 0x95, - 0xc0, 0x65, 0x1b, 0xb7, 0xb1, 0x67, 0x63, 0xcf, 0x72, 0x30, 0x5d, 0x6b, 0x90, 0x06, 0x11, 0x74, - 0xf1, 0x4b, 0x89, 0x5c, 0x8d, 0x5c, 0xe1, 0x3e, 0x58, 0xa4, 0xd5, 0x22, 0x1e, 0x37, 0xbd, 0x85, - 0x29, 0x45, 0x0d, 0x65, 0xf1, 0xc2, 0x3b, 0x31, 0x29, 0xec, 0x05, 0x2d, 0xca, 0x85, 0x18, 0xa2, - 0x07, 0xe6, 0x61, 0x80, 0x83, 0x50, 0xee, 0x7a, 0x4c, 0x8e, 0xb3, 0x05, 0xb7, 0x1f, 0xf0, 0x4a, - 0x4c, 0xf0, 0x30, 0xc0, 0xfe, 0xf1, 0xa0, 0x53, 0x05, 0xcd, 0x22, 0x6e, 0xbf, 0xdc, 0xcd, 0xb4, - 0xeb, 0xb0, 0x5c, 0x62, 0x1d, 0xf4, 0xcb, 0x5e, 0x4f, 0x93, 0x8d, 0x39, 0xa4, 0x04, 0x6f, 0xa5, - 0x09, 0x36, 0x1d, 0xca, 0x48, 0x9a, 0xa9, 0xb5, 0x34, 0xe9, 0x36, 0xf6, 0xa9, 0x43, 0x19, 0xf6, - 0x64, 0x36, 0x70, 0x70, 0xaa, 0xe4, 0xef, 0xc4, 0x5c, 0x3b, 0x22, 0xfe, 0xc1, 0xbe, 0x4b, 0x8e, - 0x06, 0xa6, 0x4e, 0xf5, 0xdf, 0x1a, 0x2c, 0xee, 0x12, 0xd7, 0xfd, 0xae, 0xd2, 0xd8, 0x43, 0xf4, - 0xe0, 0x09, 0x0f, 0xb1, 0x21, 0xe5, 0xf5, 0xcb, 0x50, 0xf4, 0x50, 0x0b, 0xd3, 0x36, 0xb2, 0xb0, - 0xe9, 0xd8, 0x65, 0x6d, 0x45, 0x5b, 0xcd, 0x1b, 0x85, 0x88, 0xb6, 0x63, 0xeb, 0x97, 0x20, 0xdf, - 0x26, 0xae, 0x8b, 0x7d, 0xce, 0xcf, 0x08, 0x7e, 0x4e, 0x12, 0x76, 0x6c, 0xfd, 0x63, 0x28, 0xf2, - 0xdf, 0xa6, 0x3a, 0xbf, 0x3c, 0xbe, 0xa2, 0xad, 0x16, 0xd6, 0xef, 0x46, 0xfe, 0x89, 0x5c, 0x4d, - 0xd8, 0x5b, 0xeb, 0xdc, 0xae, 0x9d, 0x65, 0x94, 0x51, 0xe0, 0x90, 0xa1, 0x85, 0x37, 0xa0, 0xb4, - 0x4f, 0xfc, 0x23, 0xe4, 0xdb, 0xd8, 0x36, 0x29, 0x09, 0x7c, 0x0b, 0x97, 0xb3, 0xc2, 0x8a, 0x0b, - 0x11, 0xfd, 0xa9, 0x20, 0x57, 0xff, 0x9e, 0x87, 0xa5, 0x53, 0x80, 0x65, 0x54, 0xf4, 0x25, 0x00, - 0x91, 0x84, 0x8c, 0x1c, 0x60, 0x4f, 0x38, 0x5b, 0x34, 0xf2, 0x9c, 0xb2, 0xc7, 0x09, 0xfa, 0xf7, - 0x40, 0x0f, 0x6d, 0x35, 0xf1, 0x27, 0xd8, 0x0a, 0x78, 0xf5, 0x08, 0x9f, 0x0b, 0xeb, 0x37, 0xe2, - 0x3e, 0xc9, 0xd4, 0xe7, 0xae, 0x84, 0xa7, 0x6d, 0x85, 0x0a, 0xc6, 0xec, 0x51, 0x92, 0xa4, 0xef, - 0xc0, 0x74, 0x84, 0xcc, 0x8e, 0xdb, 0x58, 0x05, 0xea, 0xea, 0x20, 0xd0, 0xbd, 0xe3, 0x36, 0x36, - 0x8a, 0x47, 0x3d, 0x4f, 0xfa, 0xfb, 0x30, 0xdf, 0xf6, 0x71, 0xc7, 0x21, 0x01, 0x35, 0x29, 0x43, - 0x3e, 0xc3, 0xb6, 0x89, 0x3b, 0xd8, 0x63, 0xfc, 0x7e, 0x78, 0x64, 0xc6, 0x8d, 0xb9, 0x50, 0xe0, - 0xa9, 0xe4, 0x6f, 0x71, 0xf6, 0x8e, 0xad, 0xaf, 0x42, 0xa9, 0x4f, 0x63, 0x42, 0x68, 0xcc, 0xd0, - 0xb8, 0x64, 0x19, 0xa6, 0x10, 0xe3, 0xb6, 0xb1, 0xf2, 0xe4, 0x8a, 0xb6, 0x3a, 0x61, 0x84, 0x8f, - 0x7a, 0x15, 0xa6, 0x3d, 0xfc, 0x09, 0xeb, 0x02, 0x4c, 0x09, 0x80, 0x02, 0x27, 0x86, 0xda, 0xb7, - 0x40, 0xaf, 0x23, 0xeb, 0xc0, 0x25, 0x0d, 0xd3, 0x22, 0x81, 0xc7, 0xcc, 0xa6, 0xe3, 0xb1, 0x72, - 0x4e, 0x08, 0x96, 0x14, 0x67, 0x93, 0x33, 0xb6, 0x1d, 0x8f, 0xe9, 0xef, 0x41, 0x99, 0x32, 0xc7, - 0x3a, 0x38, 0xee, 0xc6, 0xdc, 0xc4, 0x1e, 0xaa, 0xbb, 0xd8, 0x2e, 0xe7, 0x57, 0xb4, 0xd5, 0x9c, - 0x31, 0x27, 0xf9, 0x51, 0x38, 0xb7, 0x24, 0x57, 0xff, 0x00, 0x26, 0x44, 0x2f, 0x28, 0x43, 0x5a, - 0x34, 0x05, 0xab, 0x37, 0x98, 0x4f, 0x38, 0xc1, 0x90, 0x2a, 0xfa, 0x21, 0x5c, 0x64, 0x3e, 0xf2, - 0xa8, 0xc3, 0xdd, 0xe8, 0xde, 0x0d, 0xa2, 0x07, 0xe5, 0x82, 0x40, 0x7b, 0xbf, 0x96, 0xd6, 0x77, - 0x55, 0x49, 0x73, 0xd8, 0xbd, 0x50, 0xbd, 0x37, 0xdf, 0x76, 0xbc, 0x7d, 0x62, 0xbc, 0xcd, 0xd2, - 0x58, 0x7a, 0x03, 0x96, 0xfa, 0xd3, 0xcb, 0xec, 0x76, 0xc5, 0x72, 0x31, 0xcd, 0x8d, 0xa8, 0x2d, - 0x8a, 0x33, 0xa3, 0x94, 0x5e, 0xe8, 0x4b, 0xb2, 0x88, 0xc7, 0xab, 0xba, 0xee, 0x23, 0xcf, 0x6a, - 0xaa, 0x44, 0x9f, 0x11, 0x89, 0x5e, 0x90, 0x34, 0x99, 0xea, 0x0f, 0x61, 0x86, 0x5a, 0x4d, 0x6c, - 0x07, 0x2e, 0xb6, 0x4d, 0x3e, 0x08, 0xca, 0x17, 0xc4, 0xe1, 0x0b, 0x35, 0x39, 0x25, 0x6a, 0xe1, - 0x94, 0xa8, 0xed, 0x85, 0x53, 0x62, 0x23, 0xfb, 0xe9, 0x3f, 0x96, 0x35, 0x63, 0x3a, 0xd2, 0xe3, - 0x1c, 0x7d, 0x13, 0x8a, 0x61, 0x4e, 0x09, 0x98, 0xd2, 0x90, 0x30, 0x05, 0xa5, 0x25, 0x40, 0x5c, - 0x98, 0xe2, 0xb7, 0xe2, 0x60, 0x5a, 0x9e, 0x5d, 0x19, 0x5f, 0x2d, 0xac, 0x1b, 0xb5, 0xe1, 0x86, - 0x5e, 0xed, 0xcc, 0x7a, 0xaf, 0x3d, 0x91, 0xa0, 0x5b, 0x1e, 0xf3, 0x8f, 0x8d, 0xf0, 0x08, 0xfd, - 0x2e, 0xe4, 0x54, 0x3b, 0xa6, 0x65, 0x5d, 0x1c, 0x77, 0x39, 0x1e, 0xf2, 0x70, 0x76, 0xf0, 0x03, - 0x1e, 0x4b, 0x49, 0x23, 0x52, 0x59, 0xf8, 0x18, 0x8a, 0xbd, 0xb8, 0x7a, 0x09, 0xc6, 0x0f, 0xf0, - 0xb1, 0x6a, 0x9d, 0xfc, 0x27, 0xcf, 0xcb, 0x0e, 0x72, 0x03, 0xac, 0x5a, 0xc7, 0x90, 0x79, 0x29, - 0x54, 0x3e, 0xc8, 0xbc, 0xa7, 0x7d, 0x98, 0xcd, 0x4d, 0x97, 0x66, 0xa2, 0xe6, 0x7d, 0xdf, 0x62, - 0x4e, 0xc7, 0x61, 0xc7, 0xff, 0x57, 0xcd, 0xfb, 0x34, 0xa3, 0x46, 0x6f, 0xde, 0x39, 0xd9, 0xbc, - 0x53, 0x80, 0xdf, 0x74, 0xf3, 0x5e, 0x86, 0x02, 0x52, 0x56, 0xf1, 0x30, 0x8e, 0x0b, 0x07, 0x20, - 0x24, 0xed, 0xd8, 0xbc, 0xbb, 0x47, 0x02, 0xa2, 0xbb, 0x67, 0xcf, 0xee, 0xee, 0x91, 0x8f, 0xa2, - 0xbb, 0xa3, 0x9e, 0x27, 0xfd, 0x0e, 0x4c, 0x38, 0x5e, 0x3b, 0x60, 0xa2, 0x2f, 0x17, 0xd6, 0x57, - 0x4e, 0x83, 0xd8, 0x45, 0xc7, 0x2e, 0x41, 0x36, 0x35, 0xa4, 0x78, 0x4a, 0x3d, 0x4f, 0x8e, 0x56, - 0xcf, 0xcf, 0x60, 0x3e, 0x24, 0x98, 0x8c, 0x98, 0x96, 0x4b, 0x28, 0x16, 0x80, 0x24, 0x60, 0xa2, - 0xd7, 0x17, 0xd6, 0xe7, 0xfb, 0x30, 0x1f, 0xa8, 0x4d, 0x73, 0x23, 0xfb, 0x6b, 0x0e, 0x39, 0x17, - 0x22, 0xec, 0x91, 0x4d, 0xae, 0xbf, 0x27, 0xd5, 0xfb, 0x7a, 0x45, 0x6e, 0x94, 0x5e, 0xb1, 0x07, - 0x73, 0xe2, 0xb1, 0xdf, 0xba, 0xfc, 0x70, 0xd6, 0x7d, 0x49, 0xa8, 0x27, 0x4c, 0x7b, 0x04, 0xb3, - 0x4d, 0x8c, 0x7c, 0x56, 0xc7, 0x88, 0x45, 0x80, 0x30, 0x1c, 0x60, 0x29, 0xd2, 0x0c, 0xd1, 0x7a, - 0xc6, 0x67, 0x21, 0x3e, 0x3e, 0x31, 0x54, 0xac, 0xc0, 0xf7, 0xf9, 0xd0, 0x51, 0x24, 0x33, 0x71, - 0x6f, 0xc5, 0x21, 0x83, 0x72, 0x49, 0xe1, 0xdc, 0x97, 0x30, 0x4f, 0x63, 0xb7, 0xf8, 0xb8, 0xd7, - 0x1d, 0x1b, 0x33, 0xe4, 0xb8, 0xb4, 0x3c, 0x3d, 0x64, 0x4a, 0x75, 0xfd, 0x79, 0x20, 0x35, 0xfb, - 0xd7, 0x97, 0x99, 0x91, 0xd7, 0x97, 0x2f, 0xf7, 0x94, 0x69, 0xd4, 0xa9, 0xc4, 0xf0, 0xc9, 0x77, - 0x6b, 0xef, 0x5b, 0x21, 0x43, 0xbf, 0x03, 0x93, 0x4d, 0x8c, 0x6c, 0xec, 0xab, 0xc1, 0x52, 0x39, - 0xed, 0xc8, 0x6d, 0x21, 0x65, 0x28, 0xe9, 0xea, 0x4f, 0xb3, 0x30, 0x77, 0xdf, 0xb6, 0x7b, 0x47, - 0xc3, 0x39, 0xda, 0xe6, 0x43, 0xc8, 0xbf, 0x42, 0x0b, 0xe9, 0xea, 0xea, 0x9b, 0xaa, 0x67, 0xc9, - 0xf9, 0x3e, 0x7e, 0x8e, 0xf9, 0x2e, 0x3a, 0x9b, 0x1c, 0xe7, 0xb7, 0x40, 0xef, 0xe6, 0x48, 0x62, - 0xd5, 0x2b, 0x45, 0x9c, 0x70, 0xf9, 0x4a, 0x14, 0xb0, 0xaa, 0x15, 0x95, 0xd1, 0x13, 0xe7, 0x2e, - 0x60, 0xb1, 0x42, 0x86, 0x79, 0x9d, 0xd6, 0xcf, 0x27, 0x53, 0xfb, 0xb9, 0xfe, 0x75, 0x98, 0x54, - 0x02, 0xbc, 0x69, 0xcc, 0xac, 0xaf, 0xa6, 0x4e, 0x74, 0xf1, 0x2a, 0x15, 0x3a, 0x2e, 0x35, 0x0d, - 0xa5, 0xa7, 0xdf, 0x83, 0x09, 0xf1, 0x56, 0xa6, 0xea, 0xfa, 0x46, 0x2a, 0x80, 0x90, 0xe0, 0x00, - 0x1f, 0x61, 0x8b, 0x11, 0x7f, 0x93, 0x3f, 0x1a, 0x52, 0xaf, 0x3a, 0x0f, 0x17, 0xfb, 0x52, 0x40, - 0xce, 0x92, 0xea, 0xcf, 0x65, 0x7a, 0xf4, 0x0e, 0x9b, 0x37, 0x9f, 0x1e, 0xd9, 0xd7, 0x99, 0x1e, - 0x13, 0xa3, 0xa4, 0xc7, 0xe4, 0xeb, 0x4f, 0x8f, 0xa9, 0x41, 0xe9, 0x91, 0x7b, 0x43, 0xe9, 0xf1, - 0x61, 0x36, 0x37, 0x5e, 0xca, 0xaa, 0x24, 0x89, 0x27, 0x82, 0x4a, 0x92, 0x9f, 0x65, 0xe0, 0x2d, - 0xb1, 0x9b, 0x85, 0x77, 0x78, 0x8e, 0x14, 0x89, 0xdf, 0x6c, 0x66, 0xb4, 0x9b, 0x7d, 0x06, 0xd3, - 0x62, 0x59, 0x4c, 0x6c, 0x68, 0xef, 0x0e, 0xdc, 0xd0, 0xd2, 0xac, 0x36, 0x8a, 0x02, 0x6b, 0x84, - 0xd5, 0xec, 0x8f, 0x1a, 0xbc, 0x9d, 0x40, 0x54, 0x2b, 0xd9, 0x26, 0x14, 0x43, 0x03, 0x69, 0xe0, - 0x32, 0x11, 0x88, 0x61, 0x26, 0x4c, 0x41, 0x99, 0xc2, 0x95, 0xf4, 0x6f, 0xc2, 0x4c, 0x08, 0xf2, - 0x23, 0x6c, 0x31, 0x6c, 0x0f, 0x58, 0x9b, 0xe5, 0xba, 0xac, 0x64, 0x8d, 0xe9, 0xc3, 0xde, 0xc7, - 0xea, 0xaf, 0x32, 0xb0, 0x22, 0xcd, 0xb3, 0x85, 0x1c, 0x8f, 0xeb, 0x26, 0x69, 0xb5, 0x5d, 0xcc, - 0x85, 0xff, 0xc7, 0xf7, 0x77, 0x11, 0xa6, 0x04, 0x48, 0xb4, 0x34, 0x4e, 0xf2, 0xc7, 0x1d, 0x5b, - 0xf7, 0x60, 0xd6, 0x0a, 0x8d, 0x8a, 0x2e, 0x57, 0x96, 0xff, 0xfd, 0x81, 0x97, 0x3b, 0xc8, 0x3d, - 0xa3, 0x64, 0x25, 0x28, 0xd5, 0x2b, 0x70, 0xf9, 0x0c, 0x2d, 0x95, 0xee, 0xff, 0xd1, 0x60, 0x71, - 0x13, 0x79, 0x16, 0x76, 0xbf, 0x1d, 0x30, 0xca, 0x90, 0x67, 0x3b, 0x5e, 0x63, 0xb7, 0x67, 0x9b, - 0x1f, 0x22, 0x6c, 0x8f, 0xe0, 0x42, 0x37, 0x6c, 0x72, 0x55, 0xc8, 0x88, 0xfa, 0x4e, 0xc4, 0x2e, - 0x56, 0xd8, 0x22, 0x58, 0x62, 0x55, 0x98, 0x66, 0xbd, 0x8f, 0xaf, 0x67, 0x7a, 0xc6, 0x5e, 0x81, - 0xb2, 0xf1, 0x57, 0xa0, 0xea, 0x32, 0x2c, 0x9d, 0xe2, 0xb2, 0x0a, 0xca, 0x6f, 0x35, 0x28, 0x3f, - 0xc0, 0xd4, 0xf2, 0x9d, 0x3a, 0x1e, 0xe5, 0x05, 0xec, 0x07, 0x50, 0xb4, 0x31, 0xb5, 0xa2, 0x4b, - 0xce, 0x24, 0xbf, 0x2d, 0x9c, 0x72, 0xc9, 0xa7, 0x9d, 0x69, 0x14, 0x38, 0x5c, 0x78, 0xaf, 0x7f, - 0xd1, 0x60, 0x3e, 0x45, 0x52, 0x55, 0xe7, 0x3d, 0x98, 0x92, 0x8e, 0xd2, 0xb2, 0x26, 0x5e, 0x73, - 0xaf, 0x9d, 0x11, 0xbb, 0x5d, 0x19, 0x12, 0x6f, 0x9f, 0x18, 0xa1, 0x96, 0xfe, 0x11, 0xcc, 0xf6, - 0xdc, 0x26, 0x65, 0x88, 0x05, 0x54, 0x79, 0x70, 0x73, 0x98, 0x6b, 0x78, 0x2a, 0x34, 0x8c, 0x0b, - 0x2c, 0x4e, 0xa8, 0xfe, 0x5e, 0x83, 0xca, 0x23, 0x87, 0xb2, 0x48, 0x70, 0x17, 0xf9, 0xcc, 0xe1, - 0x03, 0x86, 0x86, 0xa1, 0x5d, 0x84, 0x7c, 0x77, 0x3b, 0x94, 0x71, 0xed, 0x12, 0xfa, 0x02, 0x3f, - 0xfe, 0xc5, 0x14, 0x70, 0xf5, 0x37, 0x19, 0x58, 0x3e, 0xd5, 0x50, 0x15, 0xe5, 0x1f, 0x43, 0xa5, - 0xfb, 0xf2, 0xd7, 0x8d, 0x56, 0x3b, 0x92, 0x54, 0xc1, 0x7f, 0x77, 0x98, 0xc3, 0x23, 0xfc, 0xc7, - 0x98, 0x21, 0x1b, 0x31, 0x64, 0x5c, 0x42, 0xc9, 0x17, 0xe2, 0xae, 0x0d, 0xfc, 0xec, 0xd8, 0xa7, - 0xab, 0xfe, 0xb3, 0x33, 0xaf, 0x74, 0xf6, 0x51, 0xf2, 0xcb, 0x4a, 0xf7, 0xec, 0xea, 0x9f, 0x35, - 0xb8, 0xfe, 0x9d, 0xb6, 0x8d, 0x18, 0xe6, 0x63, 0x01, 0xfb, 0x1b, 0x81, 0xe3, 0xda, 0x3b, 0x36, - 0xef, 0x2b, 0x88, 0x39, 0x75, 0xc7, 0x75, 0xd8, 0xf1, 0x39, 0x0a, 0xa5, 0x0e, 0x53, 0xf1, 0x1a, - 0xd9, 0x1e, 0x58, 0x23, 0x43, 0x9e, 0x6e, 0x84, 0xc0, 0xd5, 0x9b, 0xb0, 0x3a, 0x58, 0x47, 0x15, - 0xfe, 0x9f, 0x34, 0xb8, 0xfa, 0x10, 0xb3, 0xd7, 0xe2, 0x9b, 0x99, 0xf4, 0x6d, 0x6b, 0xa0, 0x6f, - 0xc3, 0x1c, 0xdd, 0x75, 0xec, 0x17, 0x1a, 0x5c, 0x1b, 0xa0, 0xa1, 0xb2, 0xb5, 0x0e, 0xb9, 0xf0, - 0x3f, 0x02, 0x35, 0xad, 0xbf, 0xf1, 0xaa, 0xb6, 0x48, 0x34, 0x23, 0xc2, 0xad, 0xfe, 0x32, 0x03, - 0xd5, 0x1d, 0xaf, 0x83, 0x5c, 0x87, 0xc7, 0x3a, 0xca, 0x9d, 0x28, 0xad, 0x86, 0x0f, 0xdc, 0x52, - 0x5f, 0x11, 0xe7, 0x7b, 0x5b, 0x7b, 0xca, 0xb4, 0x19, 0x1f, 0x7d, 0xda, 0x7c, 0x1f, 0x2e, 0x74, - 0xb0, 0x4f, 0x1d, 0xe2, 0x39, 0x5e, 0xc3, 0xe4, 0x96, 0xaa, 0x91, 0xbc, 0x9e, 0xba, 0x5a, 0xf6, - 0xfc, 0x5d, 0x23, 0x17, 0xcc, 0x50, 0xf5, 0x01, 0xf7, 0x71, 0xa6, 0x13, 0x7b, 0xae, 0x5e, 0x83, - 0x2b, 0x67, 0x86, 0x44, 0x85, 0xee, 0x77, 0x1a, 0x5c, 0x7a, 0x88, 0xd9, 0x17, 0x18, 0xb3, 0x7b, - 0xb0, 0x78, 0x84, 0x3c, 0x66, 0x26, 0x5c, 0x35, 0xad, 0xc0, 0x6f, 0x22, 0xda, 0x14, 0x01, 0x2c, - 0x1a, 0xf3, 0x5c, 0x26, 0xee, 0xd2, 0xa6, 0x14, 0xa8, 0xfe, 0x55, 0x83, 0xc5, 0x74, 0x13, 0x55, - 0x8a, 0xfd, 0xb0, 0x3f, 0x8e, 0xda, 0xa8, 0x71, 0xdc, 0x1e, 0x4b, 0x46, 0x52, 0xbf, 0x09, 0x25, - 0xf1, 0x1d, 0x58, 0x6e, 0x4e, 0xa6, 0x30, 0x9a, 0x7b, 0x99, 0xe3, 0xb2, 0x8a, 0x63, 0xe0, 0xc3, - 0x6d, 0x44, 0x9b, 0x1b, 0x73, 0xf0, 0x56, 0xd2, 0x4f, 0x9e, 0xa5, 0x1b, 0xfe, 0xf3, 0x17, 0x95, - 0xb1, 0xcf, 0x5e, 0x54, 0xc6, 0x3e, 0x7f, 0x51, 0xd1, 0x7e, 0x72, 0x52, 0xd1, 0xfe, 0x70, 0x52, - 0xd1, 0xfe, 0x76, 0x52, 0xd1, 0x9e, 0x9f, 0x54, 0xb4, 0x7f, 0x9e, 0x54, 0xb4, 0x7f, 0x9d, 0x54, - 0xc6, 0x3e, 0x3f, 0xa9, 0x68, 0x9f, 0xbe, 0xac, 0x8c, 0x3d, 0x7f, 0x59, 0x19, 0xfb, 0xec, 0x65, - 0x65, 0xec, 0xd9, 0xd7, 0x1a, 0xa4, 0xeb, 0x81, 0x43, 0xce, 0xfe, 0x37, 0xf7, 0xab, 0x09, 0x52, - 0x7d, 0x52, 0xbc, 0x4d, 0x7d, 0xe5, 0xbf, 0x01, 0x00, 0x00, 0xff, 0xff, 0x35, 0xe8, 0xbf, 0x59, - 0x0e, 0x1e, 0x00, 0x00, + // 2042 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x59, 0x4f, 0x73, 0x1b, 0x49, + 0x15, 0xf7, 0x48, 0xb2, 0x2d, 0x3d, 0xc9, 0x8e, 0x3c, 0xec, 0x3a, 0xb2, 0x63, 0xcb, 0x8e, 0x92, + 0x6c, 0x9c, 0x54, 0x90, 0x2b, 0x86, 0x4d, 0xed, 0x2e, 0x64, 0x97, 0xc4, 0x31, 0x89, 0x77, 0x13, + 0x70, 0x26, 0xde, 0x85, 0x0a, 0x54, 0xcd, 0xb6, 0x66, 0xda, 0xf2, 0xa0, 0xd1, 0xb4, 0x3c, 0xdd, + 0x23, 0xaf, 0x39, 0xc1, 0x81, 0xe2, 0xc0, 0x65, 0x29, 0x2e, 0x50, 0x1c, 0xb8, 0x51, 0xc0, 0x89, + 0x2a, 0xf8, 0x10, 0x1c, 0x38, 0xe4, 0xb8, 0x37, 0x88, 0x73, 0xa1, 0x8a, 0xcb, 0xf2, 0x0d, 0xa8, + 0xfe, 0x33, 0x33, 0x1a, 0x69, 0x6c, 0xc9, 0x8e, 0x43, 0xb8, 0xcd, 0xbc, 0x7e, 0xef, 0xd7, 0xef, + 0xff, 0x7b, 0x23, 0xc1, 0x6d, 0x86, 0xdb, 0x1d, 0xe2, 0x23, 0x77, 0x95, 0x62, 0xbf, 0x8b, 0xfd, + 0x55, 0xd4, 0x71, 0x56, 0xdb, 0x88, 0x59, 0xbb, 0x8e, 0xd7, 0xe4, 0x24, 0xc7, 0xc2, 0xab, 0xdd, + 0x9b, 0xab, 0x3e, 0xde, 0x0b, 0x30, 0x65, 0xa6, 0x8f, 0x69, 0x87, 0x78, 0x14, 0xd7, 0x3b, 0x3e, + 0x61, 0x44, 0x7f, 0x2b, 0x14, 0xaf, 0x4b, 0xf1, 0x3a, 0xea, 0x38, 0xf5, 0x3e, 0xf1, 0x7a, 0xf7, + 0xe6, 0x7c, 0xb5, 0x49, 0x48, 0xd3, 0xc5, 0xab, 0x42, 0xaa, 0x11, 0xec, 0xac, 0xda, 0x81, 0x8f, + 0x98, 0x43, 0x3c, 0x89, 0x33, 0xbf, 0xd4, 0x7f, 0xce, 0x9c, 0x36, 0xa6, 0x0c, 0xb5, 0x3b, 0x8a, + 0xe1, 0xa2, 0x8d, 0x3b, 0xd8, 0xb3, 0xb1, 0x67, 0x39, 0x98, 0xae, 0x36, 0x49, 0x93, 0x08, 0xba, + 0x78, 0x52, 0x2c, 0x97, 0x23, 0x53, 0xb8, 0x0d, 0x16, 0x69, 0xb7, 0x89, 0xc7, 0x55, 0x6f, 0x63, + 0x4a, 0x51, 0x53, 0x69, 0x3c, 0xff, 0x56, 0x82, 0x0b, 0x7b, 0x41, 0x9b, 0x72, 0x26, 0x86, 0x68, + 0xcb, 0xdc, 0x0b, 0x70, 0x10, 0xf2, 0x5d, 0x4d, 0xf0, 0xf1, 0x63, 0x71, 0x3a, 0x08, 0x78, 0x29, + 0xc1, 0xb8, 0x17, 0x60, 0xff, 0x60, 0xd8, 0xad, 0x82, 0x66, 0x11, 0x77, 0x90, 0xef, 0x7a, 0x5a, + 0x38, 0x2c, 0x97, 0x58, 0xad, 0x41, 0xde, 0xab, 0x69, 0xbc, 0x09, 0x83, 0x14, 0xe3, 0x8d, 0x34, + 0xc6, 0x5d, 0x87, 0x32, 0x92, 0xa6, 0xea, 0xd7, 0xd3, 0xb8, 0x3b, 0xd8, 0xa7, 0x0e, 0x65, 0xd8, + 0x93, 0xd9, 0x10, 0x7b, 0x8b, 0x2a, 0xa9, 0x5b, 0x09, 0x03, 0xf7, 0x89, 0xdf, 0xda, 0x71, 0xc9, + 0xfe, 0xd0, 0x04, 0xaa, 0xfd, 0x5b, 0x83, 0x85, 0x2d, 0xe2, 0xba, 0xdf, 0x53, 0x12, 0xdb, 0x88, + 0xb6, 0x1e, 0x73, 0x60, 0x43, 0xf2, 0xeb, 0x17, 0xa1, 0xe4, 0xa1, 0x36, 0xa6, 0x1d, 0x64, 0x61, + 0xd3, 0xb1, 0x2b, 0xda, 0xb2, 0xb6, 0x52, 0x30, 0x8a, 0x11, 0x6d, 0xd3, 0xd6, 0x2f, 0x40, 0xa1, + 0x43, 0x5c, 0x17, 0xfb, 0xfc, 0x3c, 0x23, 0xce, 0xf3, 0x92, 0xb0, 0x69, 0xeb, 0x9f, 0x42, 0x89, + 0x3f, 0x9b, 0xea, 0xfe, 0x4a, 0x76, 0x59, 0x5b, 0x29, 0xae, 0xdd, 0xae, 0x47, 0x89, 0xcb, 0x33, + 0xb6, 0x4f, 0xdf, 0x7a, 0xf7, 0x66, 0xfd, 0x38, 0xa5, 0x8c, 0x22, 0x87, 0x0c, 0x35, 0xbc, 0x06, + 0xe5, 0x1d, 0xe2, 0xef, 0x23, 0xdf, 0xc6, 0xb6, 0x49, 0x49, 0xe0, 0x5b, 0xb8, 0x92, 0x13, 0x5a, + 0x9c, 0x8b, 0xe8, 0x4f, 0x04, 0xb9, 0xf6, 0xf7, 0x02, 0x2c, 0x1e, 0x01, 0x2c, 0xbd, 0xa2, 0x2f, + 0x02, 0x08, 0xe7, 0x32, 0xd2, 0xc2, 0x9e, 0x30, 0xb6, 0x64, 0x14, 0x38, 0x65, 0x9b, 0x13, 0xf4, + 0xef, 0x83, 0x1e, 0xea, 0x6a, 0xe2, 0xcf, 0xb0, 0x15, 0xf0, 0x1a, 0x12, 0x36, 0x17, 0xd7, 0xae, + 0x25, 0x6d, 0x92, 0x05, 0xc0, 0x4d, 0x09, 0x6f, 0xdb, 0x08, 0x05, 0x8c, 0x99, 0xfd, 0x7e, 0x92, + 0xbe, 0x09, 0x53, 0x11, 0x32, 0x3b, 0xe8, 0x60, 0xe5, 0xa8, 0xcb, 0xc3, 0x40, 0xb7, 0x0f, 0x3a, + 0xd8, 0x28, 0xed, 0xf7, 0xbc, 0xe9, 0xef, 0xc2, 0x5c, 0xc7, 0xc7, 0x5d, 0x87, 0x04, 0xd4, 0xa4, + 0x0c, 0xf9, 0x0c, 0xdb, 0x26, 0xee, 0x62, 0x8f, 0xf1, 0xf8, 0x70, 0xcf, 0x64, 0x8d, 0xd9, 0x90, + 0xe1, 0x89, 0x3c, 0xdf, 0xe0, 0xc7, 0x9b, 0xb6, 0xbe, 0x02, 0xe5, 0x01, 0x89, 0x71, 0x21, 0x31, + 0x4d, 0x93, 0x9c, 0x15, 0x98, 0x44, 0x8c, 0xeb, 0xc6, 0x2a, 0x13, 0xcb, 0xda, 0xca, 0xb8, 0x11, + 0xbe, 0xea, 0x35, 0x98, 0xf2, 0xf0, 0x67, 0x2c, 0x06, 0x98, 0x14, 0x00, 0x45, 0x4e, 0x0c, 0xa5, + 0x6f, 0x80, 0xde, 0x40, 0x56, 0xcb, 0x25, 0x4d, 0xd3, 0x22, 0x81, 0xc7, 0xcc, 0x5d, 0xc7, 0x63, + 0x95, 0xbc, 0x60, 0x2c, 0xab, 0x93, 0x75, 0x7e, 0xf0, 0xc0, 0xf1, 0x98, 0xfe, 0x0e, 0x54, 0x28, + 0x73, 0xac, 0xd6, 0x41, 0xec, 0x73, 0x13, 0x7b, 0xa8, 0xe1, 0x62, 0xbb, 0x52, 0x58, 0xd6, 0x56, + 0xf2, 0xc6, 0xac, 0x3c, 0x8f, 0xdc, 0xb9, 0x21, 0x4f, 0xf5, 0xf7, 0x60, 0x5c, 0x74, 0x84, 0x0a, + 0xa4, 0x79, 0x53, 0x1c, 0xf5, 0x3a, 0xf3, 0x31, 0x27, 0x18, 0x52, 0x44, 0xdf, 0x83, 0xf3, 0xcc, + 0x47, 0x1e, 0x75, 0xb8, 0x19, 0x71, 0x6c, 0x10, 0x6d, 0x55, 0x8a, 0x02, 0xed, 0xdd, 0x7a, 0x5a, + 0xf7, 0x55, 0x85, 0xcd, 0x61, 0xb7, 0x43, 0xf1, 0xde, 0x7c, 0xdb, 0xf4, 0x76, 0x88, 0xf1, 0x26, + 0x4b, 0x3b, 0xd2, 0x9b, 0xb0, 0x38, 0x98, 0x5e, 0x66, 0x5c, 0xed, 0x95, 0x52, 0x9a, 0x19, 0x51, + 0x73, 0x14, 0x77, 0x46, 0x29, 0x3d, 0x3f, 0x90, 0x64, 0xd1, 0x19, 0xaf, 0xea, 0x86, 0x8f, 0x3c, + 0x6b, 0x57, 0x25, 0xfa, 0xb4, 0x48, 0xf4, 0xa2, 0xa4, 0xc9, 0x54, 0xbf, 0x0f, 0xd3, 0xd4, 0xda, + 0xc5, 0x76, 0xe0, 0x62, 0xdb, 0xe4, 0xe3, 0xa0, 0x72, 0x4e, 0x5c, 0x3e, 0x5f, 0x97, 0xb3, 0xa2, + 0x1e, 0xce, 0x8a, 0xfa, 0x76, 0x38, 0x2b, 0xee, 0xe6, 0x3e, 0xff, 0xc7, 0x92, 0x66, 0x4c, 0x45, + 0x72, 0xfc, 0x44, 0x5f, 0x87, 0x52, 0x98, 0x53, 0x02, 0xa6, 0x3c, 0x22, 0x4c, 0x51, 0x49, 0x09, + 0x10, 0x17, 0x26, 0x79, 0x54, 0x1c, 0x4c, 0x2b, 0x33, 0xcb, 0xd9, 0x95, 0xe2, 0x9a, 0x51, 0x1f, + 0x6d, 0xf4, 0xd5, 0x8f, 0xad, 0xf7, 0xfa, 0x63, 0x09, 0xba, 0xe1, 0x31, 0xff, 0xc0, 0x08, 0xaf, + 0xd0, 0x6f, 0x43, 0x5e, 0x35, 0x65, 0x5a, 0xd1, 0xc5, 0x75, 0x17, 0x93, 0x2e, 0x0f, 0x27, 0x08, + 0xbf, 0xe0, 0x91, 0xe4, 0x34, 0x22, 0x91, 0xf9, 0x4f, 0xa1, 0xd4, 0x8b, 0xab, 0x97, 0x21, 0xdb, + 0xc2, 0x07, 0xaa, 0x75, 0xf2, 0x47, 0x9e, 0x97, 0x5d, 0xe4, 0x06, 0x58, 0xb5, 0x8e, 0x11, 0xf3, + 0x52, 0x88, 0xbc, 0x97, 0x79, 0x47, 0xfb, 0x30, 0x97, 0x9f, 0x2a, 0x4f, 0x47, 0xcd, 0xfb, 0x8e, + 0xc5, 0x9c, 0xae, 0xc3, 0x0e, 0xfe, 0xaf, 0x9a, 0xf7, 0x51, 0x4a, 0x9d, 0xbe, 0x79, 0xe7, 0x65, + 0xf3, 0x4e, 0x01, 0x7e, 0xdd, 0xcd, 0x7b, 0x09, 0x8a, 0x48, 0x69, 0xc5, 0xdd, 0x98, 0x15, 0x06, + 0x40, 0x48, 0xda, 0xb4, 0x79, 0x77, 0x8f, 0x18, 0x44, 0x77, 0xcf, 0x1d, 0xdf, 0xdd, 0x23, 0x1b, + 0x45, 0x77, 0x47, 0x3d, 0x6f, 0xfa, 0x2d, 0x18, 0x77, 0xbc, 0x4e, 0xc0, 0x44, 0x5f, 0x2e, 0xae, + 0x2d, 0x1f, 0x05, 0xb1, 0x85, 0x0e, 0x5c, 0x82, 0x6c, 0x6a, 0x48, 0xf6, 0x94, 0x7a, 0x9e, 0x38, + 0x5d, 0x3d, 0x3f, 0x85, 0xb9, 0x90, 0x60, 0x32, 0x62, 0x5a, 0x2e, 0xa1, 0x58, 0x00, 0x92, 0x80, + 0x89, 0x5e, 0x5f, 0x5c, 0x9b, 0x1b, 0xc0, 0xbc, 0xa7, 0xf6, 0xcd, 0xbb, 0xb9, 0x5f, 0x73, 0xc8, + 0xd9, 0x10, 0x61, 0x9b, 0xac, 0x73, 0xf9, 0x6d, 0x29, 0x3e, 0xd0, 0x2b, 0xf2, 0xa7, 0xe9, 0x15, + 0xdb, 0x30, 0x2b, 0x5e, 0x07, 0xb5, 0x2b, 0x8c, 0xa6, 0xdd, 0x57, 0x84, 0x78, 0x9f, 0x6a, 0x0f, + 0x61, 0x66, 0x17, 0x23, 0x9f, 0x35, 0x30, 0x62, 0x11, 0x20, 0x8c, 0x06, 0x58, 0x8e, 0x24, 0x43, + 0xb4, 0x9e, 0xf1, 0x59, 0x4c, 0x8e, 0x4f, 0x0c, 0x55, 0x2b, 0xf0, 0x7d, 0x3e, 0x74, 0x14, 0xc9, + 0xec, 0x8b, 0x5b, 0x69, 0x44, 0xa7, 0x5c, 0x50, 0x38, 0x77, 0x24, 0xcc, 0x93, 0x44, 0x14, 0x1f, + 0xf5, 0x9a, 0x63, 0x63, 0x86, 0x1c, 0x97, 0x56, 0xa6, 0x46, 0x4c, 0xa9, 0xd8, 0x9e, 0x7b, 0x52, + 0x72, 0x70, 0x7d, 0x99, 0x3e, 0xf5, 0xfa, 0xf2, 0xd5, 0x9e, 0x32, 0x8d, 0x3a, 0x95, 0x18, 0x3e, + 0x85, 0xb8, 0xf6, 0xbe, 0x13, 0x1e, 0xe8, 0xb7, 0x60, 0x62, 0x17, 0x23, 0x1b, 0xfb, 0x6a, 0xb0, + 0x54, 0x8f, 0xba, 0xf2, 0x81, 0xe0, 0x32, 0x14, 0x77, 0xed, 0xa7, 0x39, 0x98, 0xbd, 0x63, 0xdb, + 0xbd, 0xa3, 0xe1, 0x04, 0x6d, 0xf3, 0x3e, 0x14, 0x5e, 0xa2, 0x85, 0xc4, 0xb2, 0xfa, 0xba, 0xea, + 0x59, 0x72, 0xbe, 0x67, 0x4f, 0x30, 0xdf, 0x45, 0x67, 0x93, 0xe3, 0xfc, 0x06, 0xe8, 0x71, 0x8e, + 0xf4, 0xad, 0x7a, 0xe5, 0xe8, 0x24, 0x5c, 0xbe, 0xfa, 0x0a, 0x58, 0xd5, 0x8a, 0xca, 0xe8, 0xf1, + 0x13, 0x17, 0xb0, 0x58, 0x21, 0xc3, 0xbc, 0x4e, 0xeb, 0xe7, 0x13, 0xa9, 0xfd, 0x5c, 0xff, 0x16, + 0x4c, 0x28, 0x06, 0xde, 0x34, 0xa6, 0xd7, 0x56, 0x52, 0x27, 0xba, 0xf8, 0xa0, 0x0a, 0x0d, 0x97, + 0x92, 0x86, 0x92, 0xd3, 0x3f, 0x80, 0x71, 0xf1, 0x6d, 0xa6, 0xea, 0xfa, 0x5a, 0x2a, 0x80, 0xe0, + 0xe0, 0x00, 0x9f, 0x60, 0x8b, 0x11, 0x7f, 0x9d, 0xbf, 0x1a, 0x52, 0xae, 0x36, 0x07, 0xe7, 0x07, + 0x52, 0x40, 0xce, 0x92, 0xda, 0xcf, 0x65, 0x7a, 0xf4, 0x0e, 0x9b, 0xd7, 0x9f, 0x1e, 0xb9, 0xb3, + 0x4c, 0x8f, 0xf1, 0xd3, 0xa4, 0xc7, 0xc4, 0xd9, 0xa7, 0xc7, 0xe4, 0xb0, 0xf4, 0xc8, 0xbf, 0xa6, + 0xf4, 0xf8, 0x30, 0x97, 0xcf, 0x96, 0x73, 0x2a, 0x49, 0x92, 0x89, 0xa0, 0x92, 0xe4, 0x67, 0x19, + 0x78, 0x43, 0xec, 0x66, 0x61, 0x0c, 0x4f, 0x90, 0x22, 0xc9, 0xc8, 0x66, 0x4e, 0x17, 0xd9, 0xa7, + 0x30, 0x25, 0x96, 0xc5, 0xbe, 0x0d, 0xed, 0xed, 0xa1, 0x1b, 0x5a, 0x9a, 0xd6, 0x46, 0x49, 0x60, + 0x9d, 0x62, 0x35, 0xfb, 0xa3, 0x06, 0x6f, 0xf6, 0x21, 0xaa, 0x95, 0x6c, 0x1d, 0x4a, 0xa1, 0x82, + 0x34, 0x70, 0x99, 0x70, 0xc4, 0x28, 0x13, 0xa6, 0xa8, 0x54, 0xe1, 0x42, 0xfa, 0x47, 0x30, 0x1d, + 0x82, 0xfc, 0x08, 0x5b, 0x0c, 0xdb, 0x43, 0xd6, 0x66, 0xb9, 0x2e, 0x2b, 0x5e, 0x63, 0x6a, 0xaf, + 0xf7, 0xb5, 0xf6, 0xab, 0x0c, 0x2c, 0x4b, 0xf5, 0x6c, 0xc1, 0xc7, 0xfd, 0xba, 0x4e, 0xda, 0x1d, + 0x17, 0x73, 0xe6, 0xff, 0x71, 0xfc, 0xce, 0xc3, 0xa4, 0x00, 0x89, 0x96, 0xc6, 0x09, 0xfe, 0xba, + 0x69, 0xeb, 0x1e, 0xcc, 0x58, 0xa1, 0x52, 0x51, 0x70, 0x65, 0xf9, 0xdf, 0x19, 0x1a, 0xdc, 0x61, + 0xe6, 0x19, 0x65, 0xab, 0x8f, 0x52, 0xbb, 0x04, 0x17, 0x8f, 0x91, 0x52, 0xe9, 0xfe, 0x1f, 0x0d, + 0x16, 0xd6, 0x91, 0x67, 0x61, 0xf7, 0xbb, 0x01, 0xa3, 0x0c, 0x79, 0xb6, 0xe3, 0x35, 0xb7, 0x7a, + 0xb6, 0xf9, 0x11, 0xdc, 0xf6, 0x10, 0xce, 0xc5, 0x6e, 0x93, 0xab, 0x42, 0x46, 0xd4, 0x77, 0x9f, + 0xef, 0x12, 0x85, 0x2d, 0x9c, 0x25, 0x56, 0x85, 0x29, 0xd6, 0xfb, 0x7a, 0x36, 0xd3, 0x33, 0xf1, + 0x09, 0x94, 0x4b, 0x7e, 0x02, 0xd5, 0x96, 0x60, 0xf1, 0x08, 0x93, 0x95, 0x53, 0x7e, 0xab, 0x41, + 0xe5, 0x1e, 0xa6, 0x96, 0xef, 0x34, 0xf0, 0x69, 0x3e, 0xc0, 0x7e, 0x08, 0x25, 0x1b, 0x53, 0x2b, + 0x0a, 0x72, 0xa6, 0xff, 0xb7, 0x85, 0x23, 0x82, 0x7c, 0xd4, 0x9d, 0x46, 0x91, 0xc3, 0x85, 0x71, + 0xfd, 0xab, 0x06, 0x73, 0x29, 0x9c, 0xaa, 0x3a, 0x3f, 0x80, 0x49, 0x69, 0x28, 0xad, 0x68, 0xe2, + 0x33, 0xf7, 0xca, 0x31, 0xbe, 0xdb, 0x92, 0x2e, 0xf1, 0x76, 0x88, 0x11, 0x4a, 0xe9, 0x9f, 0xc0, + 0x4c, 0x4f, 0x34, 0x29, 0x43, 0x2c, 0xa0, 0xca, 0x82, 0xeb, 0xa3, 0x84, 0xe1, 0x89, 0x90, 0x30, + 0xce, 0xb1, 0x24, 0xa1, 0xf6, 0x7b, 0x0d, 0xaa, 0x0f, 0x1d, 0xca, 0x22, 0xc6, 0x2d, 0xe4, 0x33, + 0x87, 0x0f, 0x18, 0x1a, 0xba, 0x76, 0x01, 0x0a, 0xf1, 0x76, 0x28, 0xfd, 0x1a, 0x13, 0x06, 0x1c, + 0x9f, 0x7d, 0x35, 0x05, 0x5c, 0xfb, 0x4d, 0x06, 0x96, 0x8e, 0x54, 0x54, 0x79, 0xf9, 0xc7, 0x50, + 0x8d, 0x3f, 0xfe, 0x62, 0x6f, 0x75, 0x22, 0x4e, 0xe5, 0xfc, 0xb7, 0x47, 0xb9, 0x3c, 0xc2, 0x7f, + 0x84, 0x19, 0xb2, 0x11, 0x43, 0xc6, 0x05, 0xd4, 0xff, 0x41, 0x1c, 0xeb, 0xc0, 0xef, 0x4e, 0xfc, + 0x74, 0x35, 0x78, 0x77, 0xe6, 0xa5, 0xee, 0xde, 0xef, 0xff, 0x65, 0x25, 0xbe, 0xbb, 0xf6, 0x67, + 0x0d, 0xae, 0x7e, 0xdc, 0xb1, 0x11, 0xc3, 0x7c, 0x2c, 0x60, 0xff, 0x6e, 0xe0, 0xb8, 0xf6, 0xa6, + 0xcd, 0xfb, 0x0a, 0x62, 0x4e, 0xc3, 0x71, 0x1d, 0x76, 0x70, 0x82, 0x42, 0x69, 0xc0, 0x64, 0xb2, + 0x46, 0x1e, 0x0c, 0xad, 0x91, 0x11, 0x6f, 0x37, 0x42, 0xe0, 0xda, 0x75, 0x58, 0x19, 0x2e, 0xa3, + 0x0a, 0xff, 0x4f, 0x1a, 0x5c, 0xbe, 0x8f, 0xd9, 0x99, 0xd8, 0x66, 0xf6, 0xdb, 0xb6, 0x31, 0xd4, + 0xb6, 0x51, 0xae, 0x8e, 0x0d, 0xfb, 0x85, 0x06, 0x57, 0x86, 0x48, 0xa8, 0x6c, 0x6d, 0x40, 0x3e, + 0xfc, 0x8f, 0x40, 0x4d, 0xeb, 0x6f, 0xbf, 0xac, 0x2e, 0x12, 0xcd, 0x88, 0x70, 0x6b, 0xbf, 0xcc, + 0x40, 0x6d, 0xd3, 0xeb, 0x22, 0xd7, 0xe1, 0xbe, 0x8e, 0x72, 0xe7, 0x63, 0x8a, 0xfd, 0x7b, 0x3c, + 0xad, 0x46, 0x77, 0xdc, 0xe2, 0x40, 0x11, 0x17, 0x7a, 0x5b, 0x7b, 0xca, 0xb4, 0xc9, 0x9e, 0x7e, + 0xda, 0xfc, 0x00, 0x0a, 0x01, 0xc5, 0xbe, 0xc9, 0x53, 0x5f, 0x0d, 0xe3, 0xf7, 0x53, 0x97, 0xca, + 0x9e, 0xbf, 0x6b, 0xe4, 0x6a, 0xe9, 0x53, 0x87, 0x78, 0xd8, 0x1e, 0xb4, 0x34, 0x1f, 0xa8, 0xa7, + 0xda, 0x15, 0xb8, 0x74, 0xac, 0x4b, 0x94, 0xeb, 0x7e, 0xa7, 0xc1, 0x85, 0xfb, 0x98, 0xbd, 0x42, + 0x9f, 0xbd, 0x0f, 0x0b, 0x2e, 0xa2, 0xcc, 0x6c, 0x79, 0x64, 0xdf, 0x33, 0x23, 0x83, 0xcd, 0xae, + 0xb4, 0x42, 0x38, 0x30, 0x6b, 0x54, 0x38, 0xcf, 0x47, 0x9c, 0x25, 0xd4, 0x40, 0x59, 0x59, 0xfb, + 0x8b, 0x06, 0x0b, 0xe9, 0x1a, 0xaa, 0x0c, 0xbb, 0x05, 0x95, 0x9e, 0xa0, 0xec, 0x22, 0x1a, 0x5f, + 0x22, 0xd4, 0xcd, 0x1b, 0x6f, 0x44, 0xda, 0x3c, 0x40, 0x34, 0x94, 0x4f, 0xba, 0x3f, 0x73, 0xb6, + 0xee, 0xbf, 0xeb, 0x3f, 0x7b, 0x5e, 0x1d, 0xfb, 0xe2, 0x79, 0x75, 0xec, 0xcb, 0xe7, 0x55, 0xed, + 0x27, 0x87, 0x55, 0xed, 0x0f, 0x87, 0x55, 0xed, 0x6f, 0x87, 0x55, 0xed, 0xd9, 0x61, 0x55, 0xfb, + 0xe7, 0x61, 0x55, 0xfb, 0xd7, 0x61, 0x75, 0xec, 0xcb, 0xc3, 0xaa, 0xf6, 0xf9, 0x8b, 0xea, 0xd8, + 0xb3, 0x17, 0xd5, 0xb1, 0x2f, 0x5e, 0x54, 0xc7, 0x9e, 0x7e, 0xb3, 0x49, 0x62, 0x0d, 0x1c, 0x72, + 0xfc, 0x9f, 0xb8, 0xdf, 0xe8, 0x23, 0x35, 0x26, 0xc4, 0xe7, 0xd3, 0xd7, 0xfe, 0x1b, 0x00, 0x00, + 0xff, 0xff, 0xb0, 0xb3, 0xdf, 0xbc, 0x05, 0x1e, 0x00, 0x00, } func (this *PollWorkflowTaskQueueRequest) Equal(that interface{}) bool { @@ -2749,14 +2714,14 @@ func (this *GetWorkerBuildIdCompatibilityResponse) Equal(that interface{}) bool } return true } -func (this *InvalidateTaskQueueMetadataRequest) Equal(that interface{}) bool { +func (this *InvalidateTaskQueueUserDataRequest) Equal(that interface{}) bool { if that == nil { return this == nil } - that1, ok := that.(*InvalidateTaskQueueMetadataRequest) + that1, ok := that.(*InvalidateTaskQueueUserDataRequest) if !ok { - that2, ok := that.(InvalidateTaskQueueMetadataRequest) + that2, ok := that.(InvalidateTaskQueueUserDataRequest) if ok { that1 = &that2 } else { @@ -2777,19 +2742,19 @@ func (this *InvalidateTaskQueueMetadataRequest) Equal(that interface{}) bool { if this.TaskQueueType != that1.TaskQueueType { return false } - if !this.VersioningData.Equal(that1.VersioningData) { + if !this.UserData.Equal(that1.UserData) { return false } return true } -func (this *InvalidateTaskQueueMetadataResponse) Equal(that interface{}) bool { +func (this *InvalidateTaskQueueUserDataResponse) Equal(that interface{}) bool { if that == nil { return this == nil } - that1, ok := that.(*InvalidateTaskQueueMetadataResponse) + that1, ok := that.(*InvalidateTaskQueueUserDataResponse) if !ok { - that2, ok := that.(InvalidateTaskQueueMetadataResponse) + that2, ok := that.(InvalidateTaskQueueUserDataResponse) if ok { that1 = &that2 } else { @@ -2803,14 +2768,14 @@ func (this *InvalidateTaskQueueMetadataResponse) Equal(that interface{}) bool { } return true } -func (this *GetTaskQueueMetadataRequest) Equal(that interface{}) bool { +func (this *GetTaskQueueUserDataRequest) Equal(that interface{}) bool { if that == nil { return this == nil } - that1, ok := that.(*GetTaskQueueMetadataRequest) + that1, ok := that.(*GetTaskQueueUserDataRequest) if !ok { - that2, ok := that.(GetTaskQueueMetadataRequest) + that2, ok := that.(GetTaskQueueUserDataRequest) if ok { that1 = &that2 } else { @@ -2828,19 +2793,19 @@ func (this *GetTaskQueueMetadataRequest) Equal(that interface{}) bool { if this.TaskQueue != that1.TaskQueue { return false } - if !bytes.Equal(this.WantVersioningDataCurhash, that1.WantVersioningDataCurhash) { + if this.LastKnownUserDataVersion != that1.LastKnownUserDataVersion { return false } return true } -func (this *GetTaskQueueMetadataResponse) Equal(that interface{}) bool { +func (this *GetTaskQueueUserDataResponse) Equal(that interface{}) bool { if that == nil { return this == nil } - that1, ok := that.(*GetTaskQueueMetadataResponse) + that1, ok := that.(*GetTaskQueueUserDataResponse) if !ok { - that2, ok := that.(GetTaskQueueMetadataResponse) + that2, ok := that.(GetTaskQueueUserDataResponse) if ok { that1 = &that2 } else { @@ -2852,61 +2817,10 @@ func (this *GetTaskQueueMetadataResponse) Equal(that interface{}) bool { } else if this == nil { return false } - if that1.VersioningDataResp == nil { - if this.VersioningDataResp != nil { - return false - } - } else if this.VersioningDataResp == nil { - return false - } else if !this.VersioningDataResp.Equal(that1.VersioningDataResp) { - return false - } - return true -} -func (this *GetTaskQueueMetadataResponse_VersioningData) Equal(that interface{}) bool { - if that == nil { - return this == nil - } - - that1, ok := that.(*GetTaskQueueMetadataResponse_VersioningData) - if !ok { - that2, ok := that.(GetTaskQueueMetadataResponse_VersioningData) - if ok { - that1 = &that2 - } else { - return false - } - } - if that1 == nil { - return this == nil - } else if this == nil { + if this.TaskQueueHasUserData != that1.TaskQueueHasUserData { return false } - if !this.VersioningData.Equal(that1.VersioningData) { - return false - } - return true -} -func (this *GetTaskQueueMetadataResponse_MatchedReqHash) Equal(that interface{}) bool { - if that == nil { - return this == nil - } - - that1, ok := that.(*GetTaskQueueMetadataResponse_MatchedReqHash) - if !ok { - that2, ok := that.(GetTaskQueueMetadataResponse_MatchedReqHash) - if ok { - that1 = &that2 - } else { - return false - } - } - if that1 == nil { - return this == nil - } else if this == nil { - return false - } - if this.MatchedReqHash != that1.MatchedReqHash { + if !this.UserData.Equal(that1.UserData) { return false } return true @@ -3278,70 +3192,55 @@ func (this *GetWorkerBuildIdCompatibilityResponse) GoString() string { s = append(s, "}") return strings.Join(s, "") } -func (this *InvalidateTaskQueueMetadataRequest) GoString() string { +func (this *InvalidateTaskQueueUserDataRequest) GoString() string { if this == nil { return "nil" } s := make([]string, 0, 8) - s = append(s, "&matchingservice.InvalidateTaskQueueMetadataRequest{") + s = append(s, "&matchingservice.InvalidateTaskQueueUserDataRequest{") s = append(s, "NamespaceId: "+fmt.Sprintf("%#v", this.NamespaceId)+",\n") s = append(s, "TaskQueue: "+fmt.Sprintf("%#v", this.TaskQueue)+",\n") s = append(s, "TaskQueueType: "+fmt.Sprintf("%#v", this.TaskQueueType)+",\n") - if this.VersioningData != nil { - s = append(s, "VersioningData: "+fmt.Sprintf("%#v", this.VersioningData)+",\n") + if this.UserData != nil { + s = append(s, "UserData: "+fmt.Sprintf("%#v", this.UserData)+",\n") } s = append(s, "}") return strings.Join(s, "") } -func (this *InvalidateTaskQueueMetadataResponse) GoString() string { +func (this *InvalidateTaskQueueUserDataResponse) GoString() string { if this == nil { return "nil" } s := make([]string, 0, 4) - s = append(s, "&matchingservice.InvalidateTaskQueueMetadataResponse{") + s = append(s, "&matchingservice.InvalidateTaskQueueUserDataResponse{") s = append(s, "}") return strings.Join(s, "") } -func (this *GetTaskQueueMetadataRequest) GoString() string { +func (this *GetTaskQueueUserDataRequest) GoString() string { if this == nil { return "nil" } s := make([]string, 0, 7) - s = append(s, "&matchingservice.GetTaskQueueMetadataRequest{") + s = append(s, "&matchingservice.GetTaskQueueUserDataRequest{") s = append(s, "NamespaceId: "+fmt.Sprintf("%#v", this.NamespaceId)+",\n") s = append(s, "TaskQueue: "+fmt.Sprintf("%#v", this.TaskQueue)+",\n") - s = append(s, "WantVersioningDataCurhash: "+fmt.Sprintf("%#v", this.WantVersioningDataCurhash)+",\n") + s = append(s, "LastKnownUserDataVersion: "+fmt.Sprintf("%#v", this.LastKnownUserDataVersion)+",\n") s = append(s, "}") return strings.Join(s, "") } -func (this *GetTaskQueueMetadataResponse) GoString() string { +func (this *GetTaskQueueUserDataResponse) GoString() string { if this == nil { return "nil" } s := make([]string, 0, 6) - s = append(s, "&matchingservice.GetTaskQueueMetadataResponse{") - if this.VersioningDataResp != nil { - s = append(s, "VersioningDataResp: "+fmt.Sprintf("%#v", this.VersioningDataResp)+",\n") + s = append(s, "&matchingservice.GetTaskQueueUserDataResponse{") + s = append(s, "TaskQueueHasUserData: "+fmt.Sprintf("%#v", this.TaskQueueHasUserData)+",\n") + if this.UserData != nil { + s = append(s, "UserData: "+fmt.Sprintf("%#v", this.UserData)+",\n") } s = append(s, "}") return strings.Join(s, "") } -func (this *GetTaskQueueMetadataResponse_VersioningData) GoString() string { - if this == nil { - return "nil" - } - s := strings.Join([]string{`&matchingservice.GetTaskQueueMetadataResponse_VersioningData{` + - `VersioningData:` + fmt.Sprintf("%#v", this.VersioningData) + `}`}, ", ") - return s -} -func (this *GetTaskQueueMetadataResponse_MatchedReqHash) GoString() string { - if this == nil { - return "nil" - } - s := strings.Join([]string{`&matchingservice.GetTaskQueueMetadataResponse_MatchedReqHash{` + - `MatchedReqHash:` + fmt.Sprintf("%#v", this.MatchedReqHash) + `}`}, ", ") - return s -} func valueToGoStringRequestResponse(v interface{}, typ string) string { rv := reflect.ValueOf(v) if rv.IsNil() { @@ -4677,7 +4576,7 @@ func (m *GetWorkerBuildIdCompatibilityResponse) MarshalToSizedBuffer(dAtA []byte return len(dAtA) - i, nil } -func (m *InvalidateTaskQueueMetadataRequest) Marshal() (dAtA []byte, err error) { +func (m *InvalidateTaskQueueUserDataRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -4687,19 +4586,19 @@ func (m *InvalidateTaskQueueMetadataRequest) Marshal() (dAtA []byte, err error) return dAtA[:n], nil } -func (m *InvalidateTaskQueueMetadataRequest) MarshalTo(dAtA []byte) (int, error) { +func (m *InvalidateTaskQueueUserDataRequest) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *InvalidateTaskQueueMetadataRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *InvalidateTaskQueueUserDataRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l - if m.VersioningData != nil { + if m.UserData != nil { { - size, err := m.VersioningData.MarshalToSizedBuffer(dAtA[:i]) + size, err := m.UserData.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } @@ -4731,7 +4630,7 @@ func (m *InvalidateTaskQueueMetadataRequest) MarshalToSizedBuffer(dAtA []byte) ( return len(dAtA) - i, nil } -func (m *InvalidateTaskQueueMetadataResponse) Marshal() (dAtA []byte, err error) { +func (m *InvalidateTaskQueueUserDataResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -4741,12 +4640,12 @@ func (m *InvalidateTaskQueueMetadataResponse) Marshal() (dAtA []byte, err error) return dAtA[:n], nil } -func (m *InvalidateTaskQueueMetadataResponse) MarshalTo(dAtA []byte) (int, error) { +func (m *InvalidateTaskQueueUserDataResponse) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *InvalidateTaskQueueMetadataResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *InvalidateTaskQueueUserDataResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int @@ -4754,7 +4653,7 @@ func (m *InvalidateTaskQueueMetadataResponse) MarshalToSizedBuffer(dAtA []byte) return len(dAtA) - i, nil } -func (m *GetTaskQueueMetadataRequest) Marshal() (dAtA []byte, err error) { +func (m *GetTaskQueueUserDataRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -4764,22 +4663,20 @@ func (m *GetTaskQueueMetadataRequest) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *GetTaskQueueMetadataRequest) MarshalTo(dAtA []byte) (int, error) { +func (m *GetTaskQueueUserDataRequest) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *GetTaskQueueMetadataRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *GetTaskQueueUserDataRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l - if len(m.WantVersioningDataCurhash) > 0 { - i -= len(m.WantVersioningDataCurhash) - copy(dAtA[i:], m.WantVersioningDataCurhash) - i = encodeVarintRequestResponse(dAtA, i, uint64(len(m.WantVersioningDataCurhash))) + if m.LastKnownUserDataVersion != 0 { + i = encodeVarintRequestResponse(dAtA, i, uint64(m.LastKnownUserDataVersion)) i-- - dAtA[i] = 0x1a + dAtA[i] = 0x18 } if len(m.TaskQueue) > 0 { i -= len(m.TaskQueue) @@ -4798,7 +4695,7 @@ func (m *GetTaskQueueMetadataRequest) MarshalToSizedBuffer(dAtA []byte) (int, er return len(dAtA) - i, nil } -func (m *GetTaskQueueMetadataResponse) Marshal() (dAtA []byte, err error) { +func (m *GetTaskQueueUserDataResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -4808,38 +4705,19 @@ func (m *GetTaskQueueMetadataResponse) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *GetTaskQueueMetadataResponse) MarshalTo(dAtA []byte) (int, error) { +func (m *GetTaskQueueUserDataResponse) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *GetTaskQueueMetadataResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *GetTaskQueueUserDataResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l - if m.VersioningDataResp != nil { + if m.UserData != nil { { - size := m.VersioningDataResp.Size() - i -= size - if _, err := m.VersioningDataResp.MarshalTo(dAtA[i:]); err != nil { - return 0, err - } - } - } - return len(dAtA) - i, nil -} - -func (m *GetTaskQueueMetadataResponse_VersioningData) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *GetTaskQueueMetadataResponse_VersioningData) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - if m.VersioningData != nil { - { - size, err := m.VersioningData.MarshalToSizedBuffer(dAtA[:i]) + size, err := m.UserData.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } @@ -4847,27 +4725,21 @@ func (m *GetTaskQueueMetadataResponse_VersioningData) MarshalToSizedBuffer(dAtA i = encodeVarintRequestResponse(dAtA, i, uint64(size)) } i-- - dAtA[i] = 0xa + dAtA[i] = 0x12 } - return len(dAtA) - i, nil -} -func (m *GetTaskQueueMetadataResponse_MatchedReqHash) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *GetTaskQueueMetadataResponse_MatchedReqHash) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - i-- - if m.MatchedReqHash { - dAtA[i] = 1 - } else { - dAtA[i] = 0 + if m.TaskQueueHasUserData { + i-- + if m.TaskQueueHasUserData { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x8 } - i-- - dAtA[i] = 0x10 return len(dAtA) - i, nil } + func encodeVarintRequestResponse(dAtA []byte, offset int, v uint64) int { offset -= sovRequestResponse(v) base := offset @@ -5422,7 +5294,7 @@ func (m *GetWorkerBuildIdCompatibilityResponse) Size() (n int) { return n } -func (m *InvalidateTaskQueueMetadataRequest) Size() (n int) { +func (m *InvalidateTaskQueueUserDataRequest) Size() (n int) { if m == nil { return 0 } @@ -5439,14 +5311,14 @@ func (m *InvalidateTaskQueueMetadataRequest) Size() (n int) { if m.TaskQueueType != 0 { n += 1 + sovRequestResponse(uint64(m.TaskQueueType)) } - if m.VersioningData != nil { - l = m.VersioningData.Size() + if m.UserData != nil { + l = m.UserData.Size() n += 1 + l + sovRequestResponse(uint64(l)) } return n } -func (m *InvalidateTaskQueueMetadataResponse) Size() (n int) { +func (m *InvalidateTaskQueueUserDataResponse) Size() (n int) { if m == nil { return 0 } @@ -5455,7 +5327,7 @@ func (m *InvalidateTaskQueueMetadataResponse) Size() (n int) { return n } -func (m *GetTaskQueueMetadataRequest) Size() (n int) { +func (m *GetTaskQueueUserDataRequest) Size() (n int) { if m == nil { return 0 } @@ -5469,46 +5341,27 @@ func (m *GetTaskQueueMetadataRequest) Size() (n int) { if l > 0 { n += 1 + l + sovRequestResponse(uint64(l)) } - l = len(m.WantVersioningDataCurhash) - if l > 0 { - n += 1 + l + sovRequestResponse(uint64(l)) + if m.LastKnownUserDataVersion != 0 { + n += 1 + sovRequestResponse(uint64(m.LastKnownUserDataVersion)) } return n } -func (m *GetTaskQueueMetadataResponse) Size() (n int) { +func (m *GetTaskQueueUserDataResponse) Size() (n int) { if m == nil { return 0 } var l int _ = l - if m.VersioningDataResp != nil { - n += m.VersioningDataResp.Size() - } - return n -} - -func (m *GetTaskQueueMetadataResponse_VersioningData) Size() (n int) { - if m == nil { - return 0 + if m.TaskQueueHasUserData { + n += 2 } - var l int - _ = l - if m.VersioningData != nil { - l = m.VersioningData.Size() + if m.UserData != nil { + l = m.UserData.Size() n += 1 + l + sovRequestResponse(uint64(l)) } return n } -func (m *GetTaskQueueMetadataResponse_MatchedReqHash) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - n += 2 - return n -} func sovRequestResponse(x uint64) (n int) { return (math_bits.Len64(x|1) + 6) / 7 @@ -5829,66 +5682,47 @@ func (this *GetWorkerBuildIdCompatibilityResponse) String() string { }, "") return s } -func (this *InvalidateTaskQueueMetadataRequest) String() string { +func (this *InvalidateTaskQueueUserDataRequest) String() string { if this == nil { return "nil" } - s := strings.Join([]string{`&InvalidateTaskQueueMetadataRequest{`, + s := strings.Join([]string{`&InvalidateTaskQueueUserDataRequest{`, `NamespaceId:` + fmt.Sprintf("%v", this.NamespaceId) + `,`, `TaskQueue:` + fmt.Sprintf("%v", this.TaskQueue) + `,`, `TaskQueueType:` + fmt.Sprintf("%v", this.TaskQueueType) + `,`, - `VersioningData:` + strings.Replace(fmt.Sprintf("%v", this.VersioningData), "VersioningData", "v19.VersioningData", 1) + `,`, + `UserData:` + strings.Replace(fmt.Sprintf("%v", this.UserData), "VersionedTaskQueueUserData", "v19.VersionedTaskQueueUserData", 1) + `,`, `}`, }, "") return s } -func (this *InvalidateTaskQueueMetadataResponse) String() string { +func (this *InvalidateTaskQueueUserDataResponse) String() string { if this == nil { return "nil" } - s := strings.Join([]string{`&InvalidateTaskQueueMetadataResponse{`, + s := strings.Join([]string{`&InvalidateTaskQueueUserDataResponse{`, `}`, }, "") return s } -func (this *GetTaskQueueMetadataRequest) String() string { +func (this *GetTaskQueueUserDataRequest) String() string { if this == nil { return "nil" } - s := strings.Join([]string{`&GetTaskQueueMetadataRequest{`, + s := strings.Join([]string{`&GetTaskQueueUserDataRequest{`, `NamespaceId:` + fmt.Sprintf("%v", this.NamespaceId) + `,`, `TaskQueue:` + fmt.Sprintf("%v", this.TaskQueue) + `,`, - `WantVersioningDataCurhash:` + fmt.Sprintf("%v", this.WantVersioningDataCurhash) + `,`, - `}`, - }, "") - return s -} -func (this *GetTaskQueueMetadataResponse) String() string { - if this == nil { - return "nil" - } - s := strings.Join([]string{`&GetTaskQueueMetadataResponse{`, - `VersioningDataResp:` + fmt.Sprintf("%v", this.VersioningDataResp) + `,`, + `LastKnownUserDataVersion:` + fmt.Sprintf("%v", this.LastKnownUserDataVersion) + `,`, `}`, }, "") return s } -func (this *GetTaskQueueMetadataResponse_VersioningData) String() string { +func (this *GetTaskQueueUserDataResponse) String() string { if this == nil { return "nil" } - s := strings.Join([]string{`&GetTaskQueueMetadataResponse_VersioningData{`, - `VersioningData:` + strings.Replace(fmt.Sprintf("%v", this.VersioningData), "VersioningData", "v19.VersioningData", 1) + `,`, - `}`, - }, "") - return s -} -func (this *GetTaskQueueMetadataResponse_MatchedReqHash) String() string { - if this == nil { - return "nil" - } - s := strings.Join([]string{`&GetTaskQueueMetadataResponse_MatchedReqHash{`, - `MatchedReqHash:` + fmt.Sprintf("%v", this.MatchedReqHash) + `,`, + s := strings.Join([]string{`&GetTaskQueueUserDataResponse{`, + `TaskQueueHasUserData:` + fmt.Sprintf("%v", this.TaskQueueHasUserData) + `,`, + `UserData:` + strings.Replace(fmt.Sprintf("%v", this.UserData), "VersionedTaskQueueUserData", "v19.VersionedTaskQueueUserData", 1) + `,`, `}`, }, "") return s @@ -9911,7 +9745,7 @@ func (m *GetWorkerBuildIdCompatibilityResponse) Unmarshal(dAtA []byte) error { } return nil } -func (m *InvalidateTaskQueueMetadataRequest) Unmarshal(dAtA []byte) error { +func (m *InvalidateTaskQueueUserDataRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -9934,10 +9768,10 @@ func (m *InvalidateTaskQueueMetadataRequest) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: InvalidateTaskQueueMetadataRequest: wiretype end group for non-group") + return fmt.Errorf("proto: InvalidateTaskQueueUserDataRequest: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: InvalidateTaskQueueMetadataRequest: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: InvalidateTaskQueueUserDataRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: @@ -10025,7 +9859,7 @@ func (m *InvalidateTaskQueueMetadataRequest) Unmarshal(dAtA []byte) error { } case 4: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field VersioningData", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field UserData", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -10052,10 +9886,10 @@ func (m *InvalidateTaskQueueMetadataRequest) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.VersioningData == nil { - m.VersioningData = &v19.VersioningData{} + if m.UserData == nil { + m.UserData = &v19.VersionedTaskQueueUserData{} } - if err := m.VersioningData.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.UserData.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex @@ -10083,7 +9917,7 @@ func (m *InvalidateTaskQueueMetadataRequest) Unmarshal(dAtA []byte) error { } return nil } -func (m *InvalidateTaskQueueMetadataResponse) Unmarshal(dAtA []byte) error { +func (m *InvalidateTaskQueueUserDataResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -10106,10 +9940,10 @@ func (m *InvalidateTaskQueueMetadataResponse) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: InvalidateTaskQueueMetadataResponse: wiretype end group for non-group") + return fmt.Errorf("proto: InvalidateTaskQueueUserDataResponse: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: InvalidateTaskQueueMetadataResponse: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: InvalidateTaskQueueUserDataResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { default: @@ -10136,7 +9970,7 @@ func (m *InvalidateTaskQueueMetadataResponse) Unmarshal(dAtA []byte) error { } return nil } -func (m *GetTaskQueueMetadataRequest) Unmarshal(dAtA []byte) error { +func (m *GetTaskQueueUserDataRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -10159,10 +9993,10 @@ func (m *GetTaskQueueMetadataRequest) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: GetTaskQueueMetadataRequest: wiretype end group for non-group") + return fmt.Errorf("proto: GetTaskQueueUserDataRequest: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: GetTaskQueueMetadataRequest: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: GetTaskQueueUserDataRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: @@ -10230,10 +10064,10 @@ func (m *GetTaskQueueMetadataRequest) Unmarshal(dAtA []byte) error { m.TaskQueue = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 3: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field WantVersioningDataCurhash", wireType) + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field LastKnownUserDataVersion", wireType) } - var byteLen int + m.LastKnownUserDataVersion = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowRequestResponse @@ -10243,26 +10077,11 @@ func (m *GetTaskQueueMetadataRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - byteLen |= int(b&0x7F) << shift + m.LastKnownUserDataVersion |= int64(b&0x7F) << shift if b < 0x80 { break } } - if byteLen < 0 { - return ErrInvalidLengthRequestResponse - } - postIndex := iNdEx + byteLen - if postIndex < 0 { - return ErrInvalidLengthRequestResponse - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.WantVersioningDataCurhash = append(m.WantVersioningDataCurhash[:0], dAtA[iNdEx:postIndex]...) - if m.WantVersioningDataCurhash == nil { - m.WantVersioningDataCurhash = []byte{} - } - iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipRequestResponse(dAtA[iNdEx:]) @@ -10287,7 +10106,7 @@ func (m *GetTaskQueueMetadataRequest) Unmarshal(dAtA []byte) error { } return nil } -func (m *GetTaskQueueMetadataResponse) Unmarshal(dAtA []byte) error { +func (m *GetTaskQueueUserDataResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -10310,15 +10129,35 @@ func (m *GetTaskQueueMetadataResponse) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: GetTaskQueueMetadataResponse: wiretype end group for non-group") + return fmt.Errorf("proto: GetTaskQueueUserDataResponse: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: GetTaskQueueMetadataResponse: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: GetTaskQueueUserDataResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field TaskQueueHasUserData", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRequestResponse + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.TaskQueueHasUserData = bool(v != 0) + case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field VersioningData", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field UserData", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -10345,33 +10184,13 @@ func (m *GetTaskQueueMetadataResponse) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - v := &v19.VersioningData{} - if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if m.UserData == nil { + m.UserData = &v19.VersionedTaskQueueUserData{} + } + if err := m.UserData.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } - m.VersioningDataResp = &GetTaskQueueMetadataResponse_VersioningData{v} iNdEx = postIndex - case 2: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field MatchedReqHash", wireType) - } - var v int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowRequestResponse - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - v |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - b := bool(v != 0) - m.VersioningDataResp = &GetTaskQueueMetadataResponse_MatchedReqHash{b} default: iNdEx = preIndex skippy, err := skipRequestResponse(dAtA[iNdEx:]) diff --git a/api/matchingservice/v1/service.pb.go b/api/matchingservice/v1/service.pb.go index 88be77db72f..9342def4f62 100644 --- a/api/matchingservice/v1/service.pb.go +++ b/api/matchingservice/v1/service.pb.go @@ -55,42 +55,42 @@ func init() { var fileDescriptor_1a5c83076e651916 = []byte{ // 566 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x96, 0x3d, 0x6f, 0xd3, 0x40, - 0x18, 0xc7, 0x7d, 0x0b, 0xc3, 0x49, 0xa8, 0xaa, 0x05, 0x42, 0x14, 0x71, 0x42, 0x0c, 0x8c, 0x8e, - 0x0a, 0x6c, 0xb4, 0x40, 0x9a, 0x40, 0x08, 0x34, 0x6a, 0xca, 0x8b, 0x90, 0x58, 0xd0, 0x25, 0x7e, - 0x08, 0xa7, 0x3a, 0x3e, 0x73, 0x3e, 0x1b, 0x65, 0xe3, 0x13, 0x20, 0x06, 0x26, 0x56, 0x24, 0xc4, - 0xc0, 0xc4, 0xd4, 0x89, 0x15, 0xc6, 0x8c, 0x1d, 0x89, 0xb3, 0x30, 0xf6, 0x23, 0x20, 0xd7, 0xb9, - 0x6b, 0xde, 0x7b, 0x71, 0xb2, 0x25, 0xce, 0xfd, 0x7f, 0xcf, 0xef, 0x1f, 0xdf, 0x49, 0x87, 0x6f, - 0x4b, 0x68, 0x07, 0x5c, 0x50, 0xaf, 0x10, 0x82, 0x88, 0x41, 0x14, 0x68, 0xc0, 0x0a, 0x6d, 0x2a, - 0x9b, 0x6f, 0x99, 0xdf, 0x4a, 0x1f, 0xb1, 0x26, 0x14, 0xe2, 0xcd, 0xc2, 0xe0, 0xa3, 0x13, 0x08, - 0x2e, 0xb9, 0x7d, 0x43, 0xa5, 0x9c, 0x2c, 0xe5, 0xd0, 0x80, 0x39, 0x63, 0x29, 0x27, 0xde, 0xdc, - 0xd8, 0x36, 0xa4, 0x0b, 0x78, 0x17, 0x41, 0x28, 0x5f, 0x0b, 0x08, 0x03, 0xee, 0x87, 0x83, 0x31, - 0x37, 0x0f, 0xd7, 0xf1, 0x5a, 0x6d, 0xb0, 0xfa, 0x59, 0xb6, 0xda, 0xfe, 0x86, 0xf0, 0xc5, 0x3a, - 0xf7, 0xbc, 0x97, 0x5c, 0x1c, 0xbc, 0xf1, 0xf8, 0xfb, 0xe7, 0x34, 0x3c, 0xd8, 0x8f, 0x20, 0x02, - 0xbb, 0xec, 0x98, 0x59, 0x39, 0x53, 0xe3, 0x4f, 0x33, 0x85, 0x8d, 0x07, 0x4b, 0x52, 0xb2, 0x02, - 0xd7, 0x2d, 0x2d, 0x5a, 0x6c, 0x4a, 0x16, 0x33, 0xd9, 0xc9, 0x29, 0x3a, 0x11, 0xcf, 0x25, 0x3a, - 0x85, 0xa2, 0x45, 0x3f, 0x23, 0xbc, 0x56, 0x74, 0xdd, 0xe1, 0x2e, 0xf6, 0x5d, 0x53, 0xf8, 0x58, - 0x50, 0xc9, 0xdd, 0xcb, 0x9d, 0x1f, 0xd7, 0x1a, 0x36, 0x5f, 0x48, 0x6b, 0x38, 0x98, 0x47, 0x6b, - 0x34, 0xaf, 0xb5, 0x3e, 0x22, 0x7c, 0x7e, 0x3f, 0x02, 0xd1, 0x51, 0xda, 0xf6, 0x96, 0x29, 0x74, - 0x24, 0xa6, 0x94, 0xb6, 0x73, 0xa6, 0xb5, 0xd0, 0x4f, 0x84, 0x2f, 0x67, 0x5f, 0xdd, 0x93, 0x25, - 0xa9, 0x6f, 0x89, 0xb7, 0x03, 0x0f, 0x24, 0xb8, 0xf6, 0x23, 0x53, 0xfc, 0x4c, 0x84, 0x12, 0xad, - 0xae, 0x80, 0x34, 0x72, 0x38, 0x4a, 0xd4, 0x6f, 0x82, 0xb7, 0x17, 0xc9, 0x50, 0x52, 0xdf, 0x65, - 0x7e, 0x2b, 0xdd, 0xa8, 0xe6, 0x87, 0x63, 0x6a, 0x7c, 0xe1, 0xc3, 0x31, 0x83, 0xa2, 0x45, 0xbf, - 0x20, 0xbc, 0x5e, 0x86, 0xb0, 0x29, 0x58, 0x03, 0x4e, 0x4f, 0xf0, 0x7d, 0x53, 0xfc, 0x44, 0x54, - 0x09, 0x16, 0x97, 0x20, 0x68, 0xb9, 0x1f, 0x08, 0x5f, 0xda, 0x65, 0xa1, 0xd4, 0xbf, 0xd5, 0xa9, - 0x90, 0x4c, 0x32, 0xee, 0x87, 0xf6, 0x43, 0xd3, 0x01, 0x33, 0x00, 0x4a, 0xb4, 0xb2, 0x34, 0x47, - 0xeb, 0xfe, 0x46, 0xf8, 0xda, 0x8b, 0xc0, 0xa5, 0x12, 0xd2, 0x6d, 0x0c, 0x62, 0x27, 0x62, 0x9e, - 0x5b, 0x75, 0xd3, 0xfd, 0x41, 0x25, 0x6b, 0x30, 0x8f, 0xc9, 0x8e, 0xbd, 0x67, 0x3a, 0xef, 0x2c, - 0x92, 0x2a, 0x50, 0x5f, 0x1d, 0x50, 0x37, 0xf9, 0x85, 0xf0, 0xd5, 0x0a, 0xc8, 0x39, 0x35, 0x76, - 0x4d, 0xa7, 0xce, 0xc5, 0xa8, 0x0e, 0xb5, 0x15, 0xd1, 0x74, 0x81, 0x43, 0x84, 0xaf, 0x54, 0xfd, - 0x98, 0x7a, 0x2c, 0xed, 0xac, 0x5f, 0x5b, 0x0d, 0x24, 0x75, 0xa9, 0xa4, 0xf6, 0x63, 0xd3, 0x81, - 0x73, 0x20, 0x4a, 0xfe, 0xc9, 0x4a, 0x58, 0x5a, 0xfd, 0x2b, 0xc2, 0x17, 0x2a, 0x20, 0x27, 0x9d, - 0x4b, 0x0b, 0xfc, 0x49, 0x33, 0x65, 0xcb, 0xcb, 0x41, 0x94, 0xe5, 0x8e, 0xe8, 0xf6, 0x88, 0x75, - 0xd4, 0x23, 0xd6, 0x71, 0x8f, 0xa0, 0x0f, 0x09, 0x41, 0xdf, 0x13, 0x82, 0xfe, 0x24, 0x04, 0x75, - 0x13, 0x82, 0xfe, 0x26, 0x04, 0xfd, 0x4b, 0x88, 0x75, 0x9c, 0x10, 0xf4, 0xa9, 0x4f, 0xac, 0x6e, - 0x9f, 0x58, 0x47, 0x7d, 0x62, 0xbd, 0xda, 0x6a, 0xf1, 0xd3, 0xf9, 0x8c, 0xcf, 0xbf, 0x35, 0xdd, - 0x19, 0x7b, 0xd4, 0x38, 0x77, 0x72, 0x6b, 0xba, 0xf5, 0x3f, 0x00, 0x00, 0xff, 0xff, 0xc3, 0x39, - 0x89, 0x97, 0xd4, 0x09, 0x00, 0x00, + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x96, 0x3f, 0x6f, 0x13, 0x31, + 0x18, 0xc6, 0xcf, 0x0b, 0x83, 0x25, 0x54, 0xf5, 0x04, 0x42, 0x14, 0x61, 0x21, 0x06, 0xc6, 0x8b, + 0x0a, 0x6c, 0xb4, 0x40, 0x9b, 0x40, 0x08, 0xb4, 0x6a, 0x0a, 0x54, 0x48, 0x2c, 0xc8, 0xc9, 0xbd, + 0x04, 0xab, 0x97, 0xf3, 0x61, 0xfb, 0x82, 0xb2, 0xf1, 0x09, 0x10, 0x03, 0x13, 0x2b, 0x12, 0x62, + 0x60, 0x62, 0xea, 0xc4, 0x0a, 0x63, 0xc6, 0x8e, 0xe4, 0xb2, 0x30, 0xf6, 0x23, 0xa0, 0xeb, 0xc5, + 0x6e, 0xfe, 0xe3, 0x5c, 0xb2, 0x25, 0x17, 0x3f, 0xbf, 0xf7, 0xf7, 0xe4, 0x6c, 0xc9, 0xf8, 0xb6, + 0x82, 0x66, 0xc4, 0x05, 0x0d, 0x0a, 0x12, 0x44, 0x0b, 0x44, 0x81, 0x46, 0xac, 0xd0, 0xa4, 0xaa, + 0xfe, 0x86, 0x85, 0x8d, 0xf4, 0x11, 0xab, 0x43, 0xa1, 0xb5, 0x5e, 0xe8, 0x7f, 0xf4, 0x22, 0xc1, + 0x15, 0x77, 0x6f, 0xe8, 0x94, 0x97, 0xa5, 0x3c, 0x1a, 0x31, 0x6f, 0x24, 0xe5, 0xb5, 0xd6, 0xd7, + 0x36, 0x2d, 0xe9, 0x02, 0xde, 0xc6, 0x20, 0xd5, 0x2b, 0x01, 0x32, 0xe2, 0xa1, 0xec, 0x8f, 0xb9, + 0x79, 0xb4, 0x8a, 0x57, 0x76, 0xfb, 0xab, 0x9f, 0x65, 0xab, 0xdd, 0xaf, 0x08, 0x5f, 0xac, 0xf2, + 0x20, 0x78, 0xc1, 0xc5, 0xe1, 0xeb, 0x80, 0xbf, 0x7b, 0x4e, 0xe5, 0xe1, 0x7e, 0x0c, 0x31, 0xb8, + 0x25, 0xcf, 0xce, 0xca, 0x9b, 0x18, 0x7f, 0x9a, 0x29, 0xac, 0x3d, 0x58, 0x90, 0x92, 0x15, 0xb8, + 0xee, 0x18, 0xd1, 0xad, 0xba, 0x62, 0x2d, 0xa6, 0xda, 0x39, 0x45, 0xc7, 0xe2, 0xb9, 0x44, 0x27, + 0x50, 0x8c, 0xe8, 0x27, 0x84, 0x57, 0xb6, 0x7c, 0x7f, 0xb0, 0x8b, 0x7b, 0xd7, 0x16, 0x3e, 0x12, + 0xd4, 0x72, 0xf7, 0x72, 0xe7, 0x47, 0xb5, 0x06, 0xcd, 0xe7, 0xd2, 0x1a, 0x0c, 0xe6, 0xd1, 0x1a, + 0xce, 0x1b, 0xad, 0x0f, 0x08, 0x9f, 0xdf, 0x8f, 0x41, 0xb4, 0xb5, 0xb6, 0xbb, 0x61, 0x0b, 0x1d, + 0x8a, 0x69, 0xa5, 0xcd, 0x9c, 0x69, 0x23, 0xf4, 0x03, 0xe1, 0xcb, 0xd9, 0x57, 0xff, 0x74, 0x49, + 0xea, 0x5b, 0xe4, 0xcd, 0x28, 0x00, 0x05, 0xbe, 0xfb, 0xc8, 0x16, 0x3f, 0x15, 0xa1, 0x45, 0x2b, + 0x4b, 0x20, 0x0d, 0x1d, 0x8e, 0x22, 0x0d, 0xeb, 0x10, 0xec, 0xc5, 0x4a, 0x2a, 0x1a, 0xfa, 0x2c, + 0x6c, 0xa4, 0x1b, 0xd5, 0xfe, 0x70, 0x4c, 0x8c, 0xcf, 0x7d, 0x38, 0xa6, 0x50, 0x8c, 0xe8, 0x67, + 0x84, 0x57, 0x4b, 0x20, 0xeb, 0x82, 0xd5, 0xe0, 0xec, 0x04, 0xdf, 0xb7, 0xc5, 0x8f, 0x45, 0xb5, + 0xe0, 0xd6, 0x02, 0x04, 0x23, 0xf7, 0x1d, 0xe1, 0x4b, 0x3b, 0x4c, 0x2a, 0xf3, 0x5b, 0x95, 0x0a, + 0xc5, 0x14, 0xe3, 0xa1, 0x74, 0x1f, 0xda, 0x0e, 0x98, 0x02, 0xd0, 0xa2, 0xe5, 0x85, 0x39, 0x46, + 0xf7, 0x17, 0xc2, 0xd7, 0x0e, 0x22, 0x9f, 0x2a, 0x48, 0xb7, 0x31, 0x88, 0xed, 0x98, 0x05, 0x7e, + 0xc5, 0x4f, 0xf7, 0x07, 0x55, 0xac, 0xc6, 0x02, 0xa6, 0xda, 0xee, 0x9e, 0xed, 0xbc, 0xff, 0x91, + 0x74, 0x81, 0xea, 0xf2, 0x80, 0xa6, 0xc9, 0x4f, 0x84, 0xaf, 0x96, 0x41, 0xcd, 0xa8, 0xb1, 0x63, + 0x3b, 0x75, 0x26, 0x46, 0x77, 0xd8, 0x5d, 0x12, 0xcd, 0x14, 0x38, 0x42, 0xf8, 0x4a, 0x25, 0x6c, + 0xd1, 0x80, 0xa5, 0x9d, 0xcd, 0x6b, 0x3b, 0x90, 0x20, 0x4a, 0x54, 0x51, 0xf7, 0xb1, 0xed, 0xc0, + 0x19, 0x10, 0x2d, 0xff, 0x64, 0x29, 0x2c, 0xa3, 0xfe, 0x05, 0xe1, 0x0b, 0x65, 0x50, 0xe3, 0xce, + 0xc5, 0x39, 0xfe, 0xa4, 0xa9, 0xb2, 0xa5, 0xc5, 0x20, 0xda, 0x72, 0x5b, 0x74, 0xba, 0xc4, 0x39, + 0xee, 0x12, 0xe7, 0xa4, 0x4b, 0xd0, 0xfb, 0x84, 0xa0, 0x6f, 0x09, 0x41, 0xbf, 0x13, 0x82, 0x3a, + 0x09, 0x41, 0x7f, 0x12, 0x82, 0xfe, 0x26, 0xc4, 0x39, 0x49, 0x08, 0xfa, 0xd8, 0x23, 0x4e, 0xa7, + 0x47, 0x9c, 0xe3, 0x1e, 0x71, 0x5e, 0x6e, 0x34, 0xf8, 0xd9, 0x7c, 0xc6, 0x67, 0xdf, 0x9a, 0xee, + 0x8c, 0x3c, 0xaa, 0x9d, 0x3b, 0xbd, 0x35, 0xdd, 0xfa, 0x17, 0x00, 0x00, 0xff, 0xff, 0xf4, 0x6f, + 0x28, 0x89, 0xd4, 0x09, 0x00, 0x00, } // Reference imports to suppress errors if they are not otherwise used. @@ -140,10 +140,10 @@ type MatchingServiceClient interface { // aip.dev/not-precedent: UpdateWorkerBuildIdOrdering RPC doesn't follow Google API format. --) UpdateWorkerBuildIdCompatibility(ctx context.Context, in *UpdateWorkerBuildIdCompatibilityRequest, opts ...grpc.CallOption) (*UpdateWorkerBuildIdCompatibilityResponse, error) GetWorkerBuildIdCompatibility(ctx context.Context, in *GetWorkerBuildIdCompatibilityRequest, opts ...grpc.CallOption) (*GetWorkerBuildIdCompatibilityResponse, error) - // Tell a task queue that some metadata has changed. - InvalidateTaskQueueMetadata(ctx context.Context, in *InvalidateTaskQueueMetadataRequest, opts ...grpc.CallOption) (*InvalidateTaskQueueMetadataResponse, error) - // Fetch some metadata about a task queue. - GetTaskQueueMetadata(ctx context.Context, in *GetTaskQueueMetadataRequest, opts ...grpc.CallOption) (*GetTaskQueueMetadataResponse, error) + // Tell a task queue that the associated user data has changed. + InvalidateTaskQueueUserData(ctx context.Context, in *InvalidateTaskQueueUserDataRequest, opts ...grpc.CallOption) (*InvalidateTaskQueueUserDataResponse, error) + // Fetch user data for a task queue, this request should always be routed to the node holding the task queue's root partition. + GetTaskQueueUserData(ctx context.Context, in *GetTaskQueueUserDataRequest, opts ...grpc.CallOption) (*GetTaskQueueUserDataResponse, error) } type matchingServiceClient struct { @@ -253,18 +253,18 @@ func (c *matchingServiceClient) GetWorkerBuildIdCompatibility(ctx context.Contex return out, nil } -func (c *matchingServiceClient) InvalidateTaskQueueMetadata(ctx context.Context, in *InvalidateTaskQueueMetadataRequest, opts ...grpc.CallOption) (*InvalidateTaskQueueMetadataResponse, error) { - out := new(InvalidateTaskQueueMetadataResponse) - err := c.cc.Invoke(ctx, "/temporal.server.api.matchingservice.v1.MatchingService/InvalidateTaskQueueMetadata", in, out, opts...) +func (c *matchingServiceClient) InvalidateTaskQueueUserData(ctx context.Context, in *InvalidateTaskQueueUserDataRequest, opts ...grpc.CallOption) (*InvalidateTaskQueueUserDataResponse, error) { + out := new(InvalidateTaskQueueUserDataResponse) + err := c.cc.Invoke(ctx, "/temporal.server.api.matchingservice.v1.MatchingService/InvalidateTaskQueueUserData", in, out, opts...) if err != nil { return nil, err } return out, nil } -func (c *matchingServiceClient) GetTaskQueueMetadata(ctx context.Context, in *GetTaskQueueMetadataRequest, opts ...grpc.CallOption) (*GetTaskQueueMetadataResponse, error) { - out := new(GetTaskQueueMetadataResponse) - err := c.cc.Invoke(ctx, "/temporal.server.api.matchingservice.v1.MatchingService/GetTaskQueueMetadata", in, out, opts...) +func (c *matchingServiceClient) GetTaskQueueUserData(ctx context.Context, in *GetTaskQueueUserDataRequest, opts ...grpc.CallOption) (*GetTaskQueueUserDataResponse, error) { + out := new(GetTaskQueueUserDataResponse) + err := c.cc.Invoke(ctx, "/temporal.server.api.matchingservice.v1.MatchingService/GetTaskQueueUserData", in, out, opts...) if err != nil { return nil, err } @@ -308,10 +308,10 @@ type MatchingServiceServer interface { // aip.dev/not-precedent: UpdateWorkerBuildIdOrdering RPC doesn't follow Google API format. --) UpdateWorkerBuildIdCompatibility(context.Context, *UpdateWorkerBuildIdCompatibilityRequest) (*UpdateWorkerBuildIdCompatibilityResponse, error) GetWorkerBuildIdCompatibility(context.Context, *GetWorkerBuildIdCompatibilityRequest) (*GetWorkerBuildIdCompatibilityResponse, error) - // Tell a task queue that some metadata has changed. - InvalidateTaskQueueMetadata(context.Context, *InvalidateTaskQueueMetadataRequest) (*InvalidateTaskQueueMetadataResponse, error) - // Fetch some metadata about a task queue. - GetTaskQueueMetadata(context.Context, *GetTaskQueueMetadataRequest) (*GetTaskQueueMetadataResponse, error) + // Tell a task queue that the associated user data has changed. + InvalidateTaskQueueUserData(context.Context, *InvalidateTaskQueueUserDataRequest) (*InvalidateTaskQueueUserDataResponse, error) + // Fetch user data for a task queue, this request should always be routed to the node holding the task queue's root partition. + GetTaskQueueUserData(context.Context, *GetTaskQueueUserDataRequest) (*GetTaskQueueUserDataResponse, error) } // UnimplementedMatchingServiceServer can be embedded to have forward compatible implementations. @@ -351,11 +351,11 @@ func (*UnimplementedMatchingServiceServer) UpdateWorkerBuildIdCompatibility(ctx func (*UnimplementedMatchingServiceServer) GetWorkerBuildIdCompatibility(ctx context.Context, req *GetWorkerBuildIdCompatibilityRequest) (*GetWorkerBuildIdCompatibilityResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method GetWorkerBuildIdCompatibility not implemented") } -func (*UnimplementedMatchingServiceServer) InvalidateTaskQueueMetadata(ctx context.Context, req *InvalidateTaskQueueMetadataRequest) (*InvalidateTaskQueueMetadataResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method InvalidateTaskQueueMetadata not implemented") +func (*UnimplementedMatchingServiceServer) InvalidateTaskQueueUserData(ctx context.Context, req *InvalidateTaskQueueUserDataRequest) (*InvalidateTaskQueueUserDataResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method InvalidateTaskQueueUserData not implemented") } -func (*UnimplementedMatchingServiceServer) GetTaskQueueMetadata(ctx context.Context, req *GetTaskQueueMetadataRequest) (*GetTaskQueueMetadataResponse, error) { - return nil, status.Errorf(codes.Unimplemented, "method GetTaskQueueMetadata not implemented") +func (*UnimplementedMatchingServiceServer) GetTaskQueueUserData(ctx context.Context, req *GetTaskQueueUserDataRequest) (*GetTaskQueueUserDataResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method GetTaskQueueUserData not implemented") } func RegisterMatchingServiceServer(s *grpc.Server, srv MatchingServiceServer) { @@ -560,38 +560,38 @@ func _MatchingService_GetWorkerBuildIdCompatibility_Handler(srv interface{}, ctx return interceptor(ctx, in, info, handler) } -func _MatchingService_InvalidateTaskQueueMetadata_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(InvalidateTaskQueueMetadataRequest) +func _MatchingService_InvalidateTaskQueueUserData_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(InvalidateTaskQueueUserDataRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { - return srv.(MatchingServiceServer).InvalidateTaskQueueMetadata(ctx, in) + return srv.(MatchingServiceServer).InvalidateTaskQueueUserData(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, - FullMethod: "/temporal.server.api.matchingservice.v1.MatchingService/InvalidateTaskQueueMetadata", + FullMethod: "/temporal.server.api.matchingservice.v1.MatchingService/InvalidateTaskQueueUserData", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(MatchingServiceServer).InvalidateTaskQueueMetadata(ctx, req.(*InvalidateTaskQueueMetadataRequest)) + return srv.(MatchingServiceServer).InvalidateTaskQueueUserData(ctx, req.(*InvalidateTaskQueueUserDataRequest)) } return interceptor(ctx, in, info, handler) } -func _MatchingService_GetTaskQueueMetadata_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { - in := new(GetTaskQueueMetadataRequest) +func _MatchingService_GetTaskQueueUserData_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(GetTaskQueueUserDataRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { - return srv.(MatchingServiceServer).GetTaskQueueMetadata(ctx, in) + return srv.(MatchingServiceServer).GetTaskQueueUserData(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, - FullMethod: "/temporal.server.api.matchingservice.v1.MatchingService/GetTaskQueueMetadata", + FullMethod: "/temporal.server.api.matchingservice.v1.MatchingService/GetTaskQueueUserData", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { - return srv.(MatchingServiceServer).GetTaskQueueMetadata(ctx, req.(*GetTaskQueueMetadataRequest)) + return srv.(MatchingServiceServer).GetTaskQueueUserData(ctx, req.(*GetTaskQueueUserDataRequest)) } return interceptor(ctx, in, info, handler) } @@ -645,12 +645,12 @@ var _MatchingService_serviceDesc = grpc.ServiceDesc{ Handler: _MatchingService_GetWorkerBuildIdCompatibility_Handler, }, { - MethodName: "InvalidateTaskQueueMetadata", - Handler: _MatchingService_InvalidateTaskQueueMetadata_Handler, + MethodName: "InvalidateTaskQueueUserData", + Handler: _MatchingService_InvalidateTaskQueueUserData_Handler, }, { - MethodName: "GetTaskQueueMetadata", - Handler: _MatchingService_GetTaskQueueMetadata_Handler, + MethodName: "GetTaskQueueUserData", + Handler: _MatchingService_GetTaskQueueUserData_Handler, }, }, Streams: []grpc.StreamDesc{}, diff --git a/api/matchingservicemock/v1/service.pb.mock.go b/api/matchingservicemock/v1/service.pb.mock.go index a0ee7795ba8..fadd2099ece 100644 --- a/api/matchingservicemock/v1/service.pb.mock.go +++ b/api/matchingservicemock/v1/service.pb.mock.go @@ -140,24 +140,24 @@ func (mr *MockMatchingServiceClientMockRecorder) DescribeTaskQueue(ctx, in inter return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTaskQueue", reflect.TypeOf((*MockMatchingServiceClient)(nil).DescribeTaskQueue), varargs...) } -// GetTaskQueueMetadata mocks base method. -func (m *MockMatchingServiceClient) GetTaskQueueMetadata(ctx context.Context, in *matchingservice.GetTaskQueueMetadataRequest, opts ...grpc.CallOption) (*matchingservice.GetTaskQueueMetadataResponse, error) { +// GetTaskQueueUserData mocks base method. +func (m *MockMatchingServiceClient) GetTaskQueueUserData(ctx context.Context, in *matchingservice.GetTaskQueueUserDataRequest, opts ...grpc.CallOption) (*matchingservice.GetTaskQueueUserDataResponse, error) { m.ctrl.T.Helper() varargs := []interface{}{ctx, in} for _, a := range opts { varargs = append(varargs, a) } - ret := m.ctrl.Call(m, "GetTaskQueueMetadata", varargs...) - ret0, _ := ret[0].(*matchingservice.GetTaskQueueMetadataResponse) + ret := m.ctrl.Call(m, "GetTaskQueueUserData", varargs...) + ret0, _ := ret[0].(*matchingservice.GetTaskQueueUserDataResponse) ret1, _ := ret[1].(error) return ret0, ret1 } -// GetTaskQueueMetadata indicates an expected call of GetTaskQueueMetadata. -func (mr *MockMatchingServiceClientMockRecorder) GetTaskQueueMetadata(ctx, in interface{}, opts ...interface{}) *gomock.Call { +// GetTaskQueueUserData indicates an expected call of GetTaskQueueUserData. +func (mr *MockMatchingServiceClientMockRecorder) GetTaskQueueUserData(ctx, in interface{}, opts ...interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() varargs := append([]interface{}{ctx, in}, opts...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTaskQueueMetadata", reflect.TypeOf((*MockMatchingServiceClient)(nil).GetTaskQueueMetadata), varargs...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTaskQueueUserData", reflect.TypeOf((*MockMatchingServiceClient)(nil).GetTaskQueueUserData), varargs...) } // GetWorkerBuildIdCompatibility mocks base method. @@ -180,24 +180,24 @@ func (mr *MockMatchingServiceClientMockRecorder) GetWorkerBuildIdCompatibility(c return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetWorkerBuildIdCompatibility", reflect.TypeOf((*MockMatchingServiceClient)(nil).GetWorkerBuildIdCompatibility), varargs...) } -// InvalidateTaskQueueMetadata mocks base method. -func (m *MockMatchingServiceClient) InvalidateTaskQueueMetadata(ctx context.Context, in *matchingservice.InvalidateTaskQueueMetadataRequest, opts ...grpc.CallOption) (*matchingservice.InvalidateTaskQueueMetadataResponse, error) { +// InvalidateTaskQueueUserData mocks base method. +func (m *MockMatchingServiceClient) InvalidateTaskQueueUserData(ctx context.Context, in *matchingservice.InvalidateTaskQueueUserDataRequest, opts ...grpc.CallOption) (*matchingservice.InvalidateTaskQueueUserDataResponse, error) { m.ctrl.T.Helper() varargs := []interface{}{ctx, in} for _, a := range opts { varargs = append(varargs, a) } - ret := m.ctrl.Call(m, "InvalidateTaskQueueMetadata", varargs...) - ret0, _ := ret[0].(*matchingservice.InvalidateTaskQueueMetadataResponse) + ret := m.ctrl.Call(m, "InvalidateTaskQueueUserData", varargs...) + ret0, _ := ret[0].(*matchingservice.InvalidateTaskQueueUserDataResponse) ret1, _ := ret[1].(error) return ret0, ret1 } -// InvalidateTaskQueueMetadata indicates an expected call of InvalidateTaskQueueMetadata. -func (mr *MockMatchingServiceClientMockRecorder) InvalidateTaskQueueMetadata(ctx, in interface{}, opts ...interface{}) *gomock.Call { +// InvalidateTaskQueueUserData indicates an expected call of InvalidateTaskQueueUserData. +func (mr *MockMatchingServiceClientMockRecorder) InvalidateTaskQueueUserData(ctx, in interface{}, opts ...interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() varargs := append([]interface{}{ctx, in}, opts...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InvalidateTaskQueueMetadata", reflect.TypeOf((*MockMatchingServiceClient)(nil).InvalidateTaskQueueMetadata), varargs...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InvalidateTaskQueueUserData", reflect.TypeOf((*MockMatchingServiceClient)(nil).InvalidateTaskQueueUserData), varargs...) } // ListTaskQueuePartitions mocks base method. @@ -403,19 +403,19 @@ func (mr *MockMatchingServiceServerMockRecorder) DescribeTaskQueue(arg0, arg1 in return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTaskQueue", reflect.TypeOf((*MockMatchingServiceServer)(nil).DescribeTaskQueue), arg0, arg1) } -// GetTaskQueueMetadata mocks base method. -func (m *MockMatchingServiceServer) GetTaskQueueMetadata(arg0 context.Context, arg1 *matchingservice.GetTaskQueueMetadataRequest) (*matchingservice.GetTaskQueueMetadataResponse, error) { +// GetTaskQueueUserData mocks base method. +func (m *MockMatchingServiceServer) GetTaskQueueUserData(arg0 context.Context, arg1 *matchingservice.GetTaskQueueUserDataRequest) (*matchingservice.GetTaskQueueUserDataResponse, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetTaskQueueMetadata", arg0, arg1) - ret0, _ := ret[0].(*matchingservice.GetTaskQueueMetadataResponse) + ret := m.ctrl.Call(m, "GetTaskQueueUserData", arg0, arg1) + ret0, _ := ret[0].(*matchingservice.GetTaskQueueUserDataResponse) ret1, _ := ret[1].(error) return ret0, ret1 } -// GetTaskQueueMetadata indicates an expected call of GetTaskQueueMetadata. -func (mr *MockMatchingServiceServerMockRecorder) GetTaskQueueMetadata(arg0, arg1 interface{}) *gomock.Call { +// GetTaskQueueUserData indicates an expected call of GetTaskQueueUserData. +func (mr *MockMatchingServiceServerMockRecorder) GetTaskQueueUserData(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTaskQueueMetadata", reflect.TypeOf((*MockMatchingServiceServer)(nil).GetTaskQueueMetadata), arg0, arg1) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTaskQueueUserData", reflect.TypeOf((*MockMatchingServiceServer)(nil).GetTaskQueueUserData), arg0, arg1) } // GetWorkerBuildIdCompatibility mocks base method. @@ -433,19 +433,19 @@ func (mr *MockMatchingServiceServerMockRecorder) GetWorkerBuildIdCompatibility(a return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetWorkerBuildIdCompatibility", reflect.TypeOf((*MockMatchingServiceServer)(nil).GetWorkerBuildIdCompatibility), arg0, arg1) } -// InvalidateTaskQueueMetadata mocks base method. -func (m *MockMatchingServiceServer) InvalidateTaskQueueMetadata(arg0 context.Context, arg1 *matchingservice.InvalidateTaskQueueMetadataRequest) (*matchingservice.InvalidateTaskQueueMetadataResponse, error) { +// InvalidateTaskQueueUserData mocks base method. +func (m *MockMatchingServiceServer) InvalidateTaskQueueUserData(arg0 context.Context, arg1 *matchingservice.InvalidateTaskQueueUserDataRequest) (*matchingservice.InvalidateTaskQueueUserDataResponse, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "InvalidateTaskQueueMetadata", arg0, arg1) - ret0, _ := ret[0].(*matchingservice.InvalidateTaskQueueMetadataResponse) + ret := m.ctrl.Call(m, "InvalidateTaskQueueUserData", arg0, arg1) + ret0, _ := ret[0].(*matchingservice.InvalidateTaskQueueUserDataResponse) ret1, _ := ret[1].(error) return ret0, ret1 } -// InvalidateTaskQueueMetadata indicates an expected call of InvalidateTaskQueueMetadata. -func (mr *MockMatchingServiceServerMockRecorder) InvalidateTaskQueueMetadata(arg0, arg1 interface{}) *gomock.Call { +// InvalidateTaskQueueUserData indicates an expected call of InvalidateTaskQueueUserData. +func (mr *MockMatchingServiceServerMockRecorder) InvalidateTaskQueueUserData(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InvalidateTaskQueueMetadata", reflect.TypeOf((*MockMatchingServiceServer)(nil).InvalidateTaskQueueMetadata), arg0, arg1) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InvalidateTaskQueueUserData", reflect.TypeOf((*MockMatchingServiceServer)(nil).InvalidateTaskQueueUserData), arg0, arg1) } // ListTaskQueuePartitions mocks base method. diff --git a/api/persistence/v1/task_queues.pb.go b/api/persistence/v1/task_queues.pb.go new file mode 100644 index 00000000000..de023e290c7 --- /dev/null +++ b/api/persistence/v1/task_queues.pb.go @@ -0,0 +1,1842 @@ +// The MIT License +// +// Copyright (c) 2020 Temporal Technologies Inc. All rights reserved. +// +// Copyright (c) 2020 Uber Technologies, Inc. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. + +// Code generated by protoc-gen-gogo. DO NOT EDIT. +// source: temporal/server/api/persistence/v1/task_queues.proto + +package persistence + +import ( + fmt "fmt" + io "io" + math "math" + math_bits "math/bits" + reflect "reflect" + strconv "strconv" + strings "strings" + + proto "github.com/gogo/protobuf/proto" + v1 "go.temporal.io/server/api/clock/v1" +) + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the proto package it is being compiled against. +// A compilation error at this line likely means your copy of the +// proto package needs to be updated. +const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package + +type BuildID_State int32 + +const ( + STATE_UNSPECIFIED BuildID_State = 0 + STATE_ACTIVE BuildID_State = 1 + STATE_DELETED BuildID_State = 2 +) + +var BuildID_State_name = map[int32]string{ + 0: "StateUnspecified", + 1: "StateActive", + 2: "StateDeleted", +} + +var BuildID_State_value = map[string]int32{ + "StateUnspecified": 0, + "StateActive": 1, + "StateDeleted": 2, +} + +func (BuildID_State) EnumDescriptor() ([]byte, []int) { + return fileDescriptor_0cb9a0f256d1327d, []int{0, 0} +} + +// BuildID is an identifier with a timestamped status used to identify workers for task queue versioning purposes. +type BuildID struct { + Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` + State BuildID_State `protobuf:"varint,2,opt,name=state,proto3,enum=temporal.server.api.persistence.v1.BuildID_State" json:"state,omitempty"` + // HLC timestamp representing when the state was updated or the when build ID was originally inserted. + // (-- api-linter: core::0142::time-field-type=disabled + // aip.dev/not-precedent: Using HLC instead of wall clock. --) + StateUpdateTimestamp *v1.HybridLogicalClock `protobuf:"bytes,3,opt,name=state_update_timestamp,json=stateUpdateTimestamp,proto3" json:"state_update_timestamp,omitempty"` +} + +func (m *BuildID) Reset() { *m = BuildID{} } +func (*BuildID) ProtoMessage() {} +func (*BuildID) Descriptor() ([]byte, []int) { + return fileDescriptor_0cb9a0f256d1327d, []int{0} +} +func (m *BuildID) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *BuildID) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_BuildID.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *BuildID) XXX_Merge(src proto.Message) { + xxx_messageInfo_BuildID.Merge(m, src) +} +func (m *BuildID) XXX_Size() int { + return m.Size() +} +func (m *BuildID) XXX_DiscardUnknown() { + xxx_messageInfo_BuildID.DiscardUnknown(m) +} + +var xxx_messageInfo_BuildID proto.InternalMessageInfo + +func (m *BuildID) GetId() string { + if m != nil { + return m.Id + } + return "" +} + +func (m *BuildID) GetState() BuildID_State { + if m != nil { + return m.State + } + return STATE_UNSPECIFIED +} + +func (m *BuildID) GetStateUpdateTimestamp() *v1.HybridLogicalClock { + if m != nil { + return m.StateUpdateTimestamp + } + return nil +} + +// An internal represenation of temporal.api.taskqueue.v1.CompatibleVersionSet +type CompatibleVersionSet struct { + // Set IDs are used internally by matching. + // A set typically has one set ID and extra care is taken to enforce this. + // In split brain scenarios, there may be conflicting concurrent writes to the task queue versioning data, in which + // case a set might end up with more than one ID. + SetIds []string `protobuf:"bytes,1,rep,name=set_ids,json=setIds,proto3" json:"set_ids,omitempty"` + // All the compatible versions, unordered except for the last element, which is considered the set "default". + BuildIds []*BuildID `protobuf:"bytes,2,rep,name=build_ids,json=buildIds,proto3" json:"build_ids,omitempty"` + // HLC timestamp representing when the set default was updated. Different from BuildID.state_update_timestamp, which + // refers to the build ID status. + // (-- api-linter: core::0142::time-field-type=disabled + // aip.dev/not-precedent: Using HLC instead of wall clock. --) + DefaultUpdateTimestamp *v1.HybridLogicalClock `protobuf:"bytes,3,opt,name=default_update_timestamp,json=defaultUpdateTimestamp,proto3" json:"default_update_timestamp,omitempty"` +} + +func (m *CompatibleVersionSet) Reset() { *m = CompatibleVersionSet{} } +func (*CompatibleVersionSet) ProtoMessage() {} +func (*CompatibleVersionSet) Descriptor() ([]byte, []int) { + return fileDescriptor_0cb9a0f256d1327d, []int{1} +} +func (m *CompatibleVersionSet) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *CompatibleVersionSet) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_CompatibleVersionSet.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *CompatibleVersionSet) XXX_Merge(src proto.Message) { + xxx_messageInfo_CompatibleVersionSet.Merge(m, src) +} +func (m *CompatibleVersionSet) XXX_Size() int { + return m.Size() +} +func (m *CompatibleVersionSet) XXX_DiscardUnknown() { + xxx_messageInfo_CompatibleVersionSet.DiscardUnknown(m) +} + +var xxx_messageInfo_CompatibleVersionSet proto.InternalMessageInfo + +func (m *CompatibleVersionSet) GetSetIds() []string { + if m != nil { + return m.SetIds + } + return nil +} + +func (m *CompatibleVersionSet) GetBuildIds() []*BuildID { + if m != nil { + return m.BuildIds + } + return nil +} + +func (m *CompatibleVersionSet) GetDefaultUpdateTimestamp() *v1.HybridLogicalClock { + if m != nil { + return m.DefaultUpdateTimestamp + } + return nil +} + +// Holds all the data related to worker versioning for a task queue. +// Backwards-incompatible changes cannot be made, as this would make existing stored data unreadable. +type VersioningData struct { + // All the incompatible version sets, unordered except for the last element, which is considered the set "default". + VersionSets []*CompatibleVersionSet `protobuf:"bytes,1,rep,name=version_sets,json=versionSets,proto3" json:"version_sets,omitempty"` + // HLC timestamp representing when the default set was last updated or established. + // (-- api-linter: core::0142::time-field-type=disabled + // aip.dev/not-precedent: Using HLC instead of wall clock. --) + DefaultUpdateTimestamp *v1.HybridLogicalClock `protobuf:"bytes,2,opt,name=default_update_timestamp,json=defaultUpdateTimestamp,proto3" json:"default_update_timestamp,omitempty"` +} + +func (m *VersioningData) Reset() { *m = VersioningData{} } +func (*VersioningData) ProtoMessage() {} +func (*VersioningData) Descriptor() ([]byte, []int) { + return fileDescriptor_0cb9a0f256d1327d, []int{2} +} +func (m *VersioningData) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *VersioningData) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_VersioningData.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *VersioningData) XXX_Merge(src proto.Message) { + xxx_messageInfo_VersioningData.Merge(m, src) +} +func (m *VersioningData) XXX_Size() int { + return m.Size() +} +func (m *VersioningData) XXX_DiscardUnknown() { + xxx_messageInfo_VersioningData.DiscardUnknown(m) +} + +var xxx_messageInfo_VersioningData proto.InternalMessageInfo + +func (m *VersioningData) GetVersionSets() []*CompatibleVersionSet { + if m != nil { + return m.VersionSets + } + return nil +} + +func (m *VersioningData) GetDefaultUpdateTimestamp() *v1.HybridLogicalClock { + if m != nil { + return m.DefaultUpdateTimestamp + } + return nil +} + +// Container for all persistent user provided data for a task queue. +// Task queue as a named concept here is close to how users interpret them, rather than relating to some specific type +// (workflow vs activity, etc) and thus, as a consequence, any data that applies to a specific type (say, activity rate +// limiting) should be defined as such within this structure. +// This data must all fit in a single DB column and is kept cached in-memory, take extra care to ensure data added here +// has reasonable size limits imposed on it. +type TaskQueueUserData struct { + // The last recorded cluster-local Hybrid Logical Clock timestamp for _this_ task queue. + // Updated whenever user data is directly updated due to a user action but not when applying replication events. + // The clock is referenced when new timestamps are generated to ensure it produces monotonically increasing + // timestamps. + Clock *v1.HybridLogicalClock `protobuf:"bytes,1,opt,name=clock,proto3" json:"clock,omitempty"` + VersioningData *VersioningData `protobuf:"bytes,2,opt,name=versioning_data,json=versioningData,proto3" json:"versioning_data,omitempty"` +} + +func (m *TaskQueueUserData) Reset() { *m = TaskQueueUserData{} } +func (*TaskQueueUserData) ProtoMessage() {} +func (*TaskQueueUserData) Descriptor() ([]byte, []int) { + return fileDescriptor_0cb9a0f256d1327d, []int{3} +} +func (m *TaskQueueUserData) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *TaskQueueUserData) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_TaskQueueUserData.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *TaskQueueUserData) XXX_Merge(src proto.Message) { + xxx_messageInfo_TaskQueueUserData.Merge(m, src) +} +func (m *TaskQueueUserData) XXX_Size() int { + return m.Size() +} +func (m *TaskQueueUserData) XXX_DiscardUnknown() { + xxx_messageInfo_TaskQueueUserData.DiscardUnknown(m) +} + +var xxx_messageInfo_TaskQueueUserData proto.InternalMessageInfo + +func (m *TaskQueueUserData) GetClock() *v1.HybridLogicalClock { + if m != nil { + return m.Clock + } + return nil +} + +func (m *TaskQueueUserData) GetVersioningData() *VersioningData { + if m != nil { + return m.VersioningData + } + return nil +} + +// Simple wrapper that includes a TaskQueueUserData and its storage version. +type VersionedTaskQueueUserData struct { + Data *TaskQueueUserData `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty"` + Version int64 `protobuf:"varint,2,opt,name=version,proto3" json:"version,omitempty"` +} + +func (m *VersionedTaskQueueUserData) Reset() { *m = VersionedTaskQueueUserData{} } +func (*VersionedTaskQueueUserData) ProtoMessage() {} +func (*VersionedTaskQueueUserData) Descriptor() ([]byte, []int) { + return fileDescriptor_0cb9a0f256d1327d, []int{4} +} +func (m *VersionedTaskQueueUserData) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *VersionedTaskQueueUserData) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_VersionedTaskQueueUserData.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *VersionedTaskQueueUserData) XXX_Merge(src proto.Message) { + xxx_messageInfo_VersionedTaskQueueUserData.Merge(m, src) +} +func (m *VersionedTaskQueueUserData) XXX_Size() int { + return m.Size() +} +func (m *VersionedTaskQueueUserData) XXX_DiscardUnknown() { + xxx_messageInfo_VersionedTaskQueueUserData.DiscardUnknown(m) +} + +var xxx_messageInfo_VersionedTaskQueueUserData proto.InternalMessageInfo + +func (m *VersionedTaskQueueUserData) GetData() *TaskQueueUserData { + if m != nil { + return m.Data + } + return nil +} + +func (m *VersionedTaskQueueUserData) GetVersion() int64 { + if m != nil { + return m.Version + } + return 0 +} + +func init() { + proto.RegisterEnum("temporal.server.api.persistence.v1.BuildID_State", BuildID_State_name, BuildID_State_value) + proto.RegisterType((*BuildID)(nil), "temporal.server.api.persistence.v1.BuildID") + proto.RegisterType((*CompatibleVersionSet)(nil), "temporal.server.api.persistence.v1.CompatibleVersionSet") + proto.RegisterType((*VersioningData)(nil), "temporal.server.api.persistence.v1.VersioningData") + proto.RegisterType((*TaskQueueUserData)(nil), "temporal.server.api.persistence.v1.TaskQueueUserData") + proto.RegisterType((*VersionedTaskQueueUserData)(nil), "temporal.server.api.persistence.v1.VersionedTaskQueueUserData") +} + +func init() { + proto.RegisterFile("temporal/server/api/persistence/v1/task_queues.proto", fileDescriptor_0cb9a0f256d1327d) +} + +var fileDescriptor_0cb9a0f256d1327d = []byte{ + // 577 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x94, 0x41, 0x6f, 0xd3, 0x3c, + 0x1c, 0xc6, 0xe3, 0xf4, 0xdd, 0xf6, 0xce, 0x1d, 0xa5, 0xb5, 0xc6, 0x88, 0x76, 0xb0, 0xaa, 0x9e, + 0x2a, 0x90, 0x52, 0x5a, 0x86, 0x84, 0xc4, 0x69, 0x6b, 0x33, 0x16, 0x69, 0x42, 0x90, 0xa6, 0x3b, + 0xb0, 0x43, 0xe4, 0x36, 0x5e, 0xe5, 0x35, 0x6d, 0x42, 0xec, 0x46, 0xe2, 0x06, 0x9f, 0x00, 0x3e, + 0x06, 0x1f, 0x81, 0x8f, 0xc0, 0xb1, 0xc7, 0x71, 0xa3, 0xa9, 0x90, 0x38, 0xee, 0x23, 0xa0, 0x38, + 0xe9, 0xd8, 0x58, 0x81, 0x82, 0x76, 0xaa, 0xfd, 0x6f, 0x9e, 0xdf, 0xe3, 0xe7, 0x51, 0x62, 0xb8, + 0x23, 0xe8, 0x30, 0xf0, 0x43, 0xe2, 0xd5, 0x38, 0x0d, 0x23, 0x1a, 0xd6, 0x48, 0xc0, 0x6a, 0x01, + 0x0d, 0x39, 0xe3, 0x82, 0x8e, 0x7a, 0xb4, 0x16, 0xd5, 0x6b, 0x82, 0xf0, 0x81, 0xf3, 0x6a, 0x4c, + 0xc7, 0x94, 0xeb, 0x41, 0xe8, 0x0b, 0x1f, 0x55, 0xe6, 0x2a, 0x3d, 0x55, 0xe9, 0x24, 0x60, 0xfa, + 0x25, 0x95, 0x1e, 0xd5, 0xb7, 0xef, 0x2d, 0x22, 0xf7, 0x3c, 0xbf, 0x37, 0x48, 0x98, 0x43, 0xca, + 0x39, 0xe9, 0xd3, 0x94, 0x57, 0x79, 0xa7, 0xc2, 0xb5, 0xbd, 0x31, 0xf3, 0x5c, 0xb3, 0x85, 0x0a, + 0x50, 0x65, 0xae, 0x06, 0xca, 0xa0, 0xba, 0x6e, 0xa9, 0xcc, 0x45, 0x4f, 0xe1, 0x0a, 0x17, 0x44, + 0x50, 0x4d, 0x2d, 0x83, 0x6a, 0xa1, 0x51, 0xd7, 0xff, 0xec, 0xad, 0x67, 0x2c, 0xbd, 0x9d, 0x08, + 0xad, 0x54, 0x8f, 0x4e, 0xe0, 0x96, 0x5c, 0x38, 0xe3, 0xc0, 0x4d, 0x7e, 0x04, 0x1b, 0x52, 0x2e, + 0xc8, 0x30, 0xd0, 0x72, 0x65, 0x50, 0xcd, 0x37, 0x1e, 0x2c, 0x24, 0xcb, 0x13, 0x27, 0xcc, 0x83, + 0xd7, 0xdd, 0x90, 0xb9, 0x87, 0x7e, 0x9f, 0xf5, 0x88, 0xd7, 0x4c, 0xa6, 0xd6, 0xa6, 0xe4, 0x75, + 0x24, 0xce, 0x9e, 0xd3, 0x2a, 0x4d, 0xb8, 0x22, 0x7d, 0xd1, 0x1d, 0x58, 0x6a, 0xdb, 0xbb, 0xb6, + 0xe1, 0x74, 0x9e, 0xb5, 0x9f, 0x1b, 0x4d, 0x73, 0xdf, 0x34, 0x5a, 0x45, 0x05, 0x15, 0xe1, 0x46, + 0x3a, 0xde, 0x6d, 0xda, 0xe6, 0x91, 0x51, 0x04, 0xa8, 0x04, 0x6f, 0xa5, 0x93, 0x96, 0x71, 0x68, + 0xd8, 0x46, 0xab, 0xa8, 0x56, 0xbe, 0x02, 0xb8, 0xd9, 0xf4, 0x87, 0x01, 0x11, 0xac, 0xeb, 0xd1, + 0xa3, 0x24, 0x9e, 0x3f, 0x6a, 0x53, 0x81, 0xee, 0xc2, 0x35, 0x4e, 0x85, 0xc3, 0x5c, 0xae, 0x81, + 0x72, 0xae, 0xba, 0x6e, 0xad, 0x72, 0x2a, 0x4c, 0x97, 0xa3, 0x03, 0xb8, 0xde, 0x4d, 0x62, 0xcb, + 0xbf, 0xd4, 0x72, 0xae, 0x9a, 0x6f, 0xdc, 0xff, 0x8b, 0xae, 0xac, 0xff, 0xa5, 0x3a, 0x21, 0x9d, + 0x42, 0xcd, 0xa5, 0x27, 0x64, 0xec, 0x89, 0x9b, 0xab, 0x6a, 0x2b, 0x23, 0xfe, 0x5c, 0xd6, 0x67, + 0x00, 0x0b, 0x59, 0x3a, 0x36, 0xea, 0xb7, 0x88, 0x20, 0xe8, 0x18, 0x6e, 0x44, 0xe9, 0xc4, 0xe1, + 0x54, 0xa4, 0x31, 0xf3, 0x8d, 0xc7, 0xcb, 0x64, 0x59, 0xd4, 0x98, 0x95, 0x8f, 0x2e, 0xd6, 0xbf, + 0xcf, 0xa6, 0xde, 0x70, 0xb6, 0x8f, 0x00, 0x96, 0x6c, 0xc2, 0x07, 0x2f, 0x92, 0x4f, 0xa7, 0xc3, + 0x69, 0x28, 0xe3, 0xed, 0xc3, 0x15, 0x09, 0x93, 0xaf, 0xf8, 0xbf, 0xd8, 0xa5, 0x72, 0x74, 0x0c, + 0x6f, 0x47, 0x17, 0xc5, 0x39, 0x2e, 0x11, 0x24, 0x0b, 0xd0, 0x58, 0xa6, 0xa9, 0xab, 0x9d, 0x5b, + 0x85, 0xe8, 0xca, 0xbe, 0xf2, 0x16, 0xc0, 0xed, 0xec, 0x11, 0xea, 0x5e, 0xcf, 0x60, 0xc2, 0xff, + 0xa4, 0x61, 0x1a, 0xe1, 0xd1, 0x32, 0x86, 0xd7, 0x20, 0x96, 0x44, 0x20, 0x0d, 0xae, 0x65, 0xde, + 0xf2, 0xf8, 0x39, 0x6b, 0xbe, 0xdd, 0x3b, 0x9d, 0x4c, 0xb1, 0x72, 0x36, 0xc5, 0xca, 0xf9, 0x14, + 0x83, 0x37, 0x31, 0x06, 0x1f, 0x62, 0x0c, 0x3e, 0xc5, 0x18, 0x4c, 0x62, 0x0c, 0xbe, 0xc4, 0x18, + 0x7c, 0x8b, 0xb1, 0x72, 0x1e, 0x63, 0xf0, 0x7e, 0x86, 0x95, 0xc9, 0x0c, 0x2b, 0x67, 0x33, 0xac, + 0xbc, 0xdc, 0xe9, 0xfb, 0x3f, 0x8e, 0xc3, 0xfc, 0x5f, 0x5f, 0x6b, 0x4f, 0x2e, 0x6d, 0xbb, 0xab, + 0xf2, 0x1e, 0x7a, 0xf8, 0x3d, 0x00, 0x00, 0xff, 0xff, 0x5d, 0xb3, 0x9f, 0xdd, 0x0f, 0x05, 0x00, + 0x00, +} + +func (x BuildID_State) String() string { + s, ok := BuildID_State_name[int32(x)] + if ok { + return s + } + return strconv.Itoa(int(x)) +} +func (this *BuildID) Equal(that interface{}) bool { + if that == nil { + return this == nil + } + + that1, ok := that.(*BuildID) + if !ok { + that2, ok := that.(BuildID) + if ok { + that1 = &that2 + } else { + return false + } + } + if that1 == nil { + return this == nil + } else if this == nil { + return false + } + if this.Id != that1.Id { + return false + } + if this.State != that1.State { + return false + } + if !this.StateUpdateTimestamp.Equal(that1.StateUpdateTimestamp) { + return false + } + return true +} +func (this *CompatibleVersionSet) Equal(that interface{}) bool { + if that == nil { + return this == nil + } + + that1, ok := that.(*CompatibleVersionSet) + if !ok { + that2, ok := that.(CompatibleVersionSet) + if ok { + that1 = &that2 + } else { + return false + } + } + if that1 == nil { + return this == nil + } else if this == nil { + return false + } + if len(this.SetIds) != len(that1.SetIds) { + return false + } + for i := range this.SetIds { + if this.SetIds[i] != that1.SetIds[i] { + return false + } + } + if len(this.BuildIds) != len(that1.BuildIds) { + return false + } + for i := range this.BuildIds { + if !this.BuildIds[i].Equal(that1.BuildIds[i]) { + return false + } + } + if !this.DefaultUpdateTimestamp.Equal(that1.DefaultUpdateTimestamp) { + return false + } + return true +} +func (this *VersioningData) Equal(that interface{}) bool { + if that == nil { + return this == nil + } + + that1, ok := that.(*VersioningData) + if !ok { + that2, ok := that.(VersioningData) + if ok { + that1 = &that2 + } else { + return false + } + } + if that1 == nil { + return this == nil + } else if this == nil { + return false + } + if len(this.VersionSets) != len(that1.VersionSets) { + return false + } + for i := range this.VersionSets { + if !this.VersionSets[i].Equal(that1.VersionSets[i]) { + return false + } + } + if !this.DefaultUpdateTimestamp.Equal(that1.DefaultUpdateTimestamp) { + return false + } + return true +} +func (this *TaskQueueUserData) Equal(that interface{}) bool { + if that == nil { + return this == nil + } + + that1, ok := that.(*TaskQueueUserData) + if !ok { + that2, ok := that.(TaskQueueUserData) + if ok { + that1 = &that2 + } else { + return false + } + } + if that1 == nil { + return this == nil + } else if this == nil { + return false + } + if !this.Clock.Equal(that1.Clock) { + return false + } + if !this.VersioningData.Equal(that1.VersioningData) { + return false + } + return true +} +func (this *VersionedTaskQueueUserData) Equal(that interface{}) bool { + if that == nil { + return this == nil + } + + that1, ok := that.(*VersionedTaskQueueUserData) + if !ok { + that2, ok := that.(VersionedTaskQueueUserData) + if ok { + that1 = &that2 + } else { + return false + } + } + if that1 == nil { + return this == nil + } else if this == nil { + return false + } + if !this.Data.Equal(that1.Data) { + return false + } + if this.Version != that1.Version { + return false + } + return true +} +func (this *BuildID) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 7) + s = append(s, "&persistence.BuildID{") + s = append(s, "Id: "+fmt.Sprintf("%#v", this.Id)+",\n") + s = append(s, "State: "+fmt.Sprintf("%#v", this.State)+",\n") + if this.StateUpdateTimestamp != nil { + s = append(s, "StateUpdateTimestamp: "+fmt.Sprintf("%#v", this.StateUpdateTimestamp)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *CompatibleVersionSet) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 7) + s = append(s, "&persistence.CompatibleVersionSet{") + s = append(s, "SetIds: "+fmt.Sprintf("%#v", this.SetIds)+",\n") + if this.BuildIds != nil { + s = append(s, "BuildIds: "+fmt.Sprintf("%#v", this.BuildIds)+",\n") + } + if this.DefaultUpdateTimestamp != nil { + s = append(s, "DefaultUpdateTimestamp: "+fmt.Sprintf("%#v", this.DefaultUpdateTimestamp)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *VersioningData) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 6) + s = append(s, "&persistence.VersioningData{") + if this.VersionSets != nil { + s = append(s, "VersionSets: "+fmt.Sprintf("%#v", this.VersionSets)+",\n") + } + if this.DefaultUpdateTimestamp != nil { + s = append(s, "DefaultUpdateTimestamp: "+fmt.Sprintf("%#v", this.DefaultUpdateTimestamp)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *TaskQueueUserData) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 6) + s = append(s, "&persistence.TaskQueueUserData{") + if this.Clock != nil { + s = append(s, "Clock: "+fmt.Sprintf("%#v", this.Clock)+",\n") + } + if this.VersioningData != nil { + s = append(s, "VersioningData: "+fmt.Sprintf("%#v", this.VersioningData)+",\n") + } + s = append(s, "}") + return strings.Join(s, "") +} +func (this *VersionedTaskQueueUserData) GoString() string { + if this == nil { + return "nil" + } + s := make([]string, 0, 6) + s = append(s, "&persistence.VersionedTaskQueueUserData{") + if this.Data != nil { + s = append(s, "Data: "+fmt.Sprintf("%#v", this.Data)+",\n") + } + s = append(s, "Version: "+fmt.Sprintf("%#v", this.Version)+",\n") + s = append(s, "}") + return strings.Join(s, "") +} +func valueToGoStringTaskQueues(v interface{}, typ string) string { + rv := reflect.ValueOf(v) + if rv.IsNil() { + return "nil" + } + pv := reflect.Indirect(rv).Interface() + return fmt.Sprintf("func(v %v) *%v { return &v } ( %#v )", typ, typ, pv) +} +func (m *BuildID) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *BuildID) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *BuildID) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.StateUpdateTimestamp != nil { + { + size, err := m.StateUpdateTimestamp.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTaskQueues(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + } + if m.State != 0 { + i = encodeVarintTaskQueues(dAtA, i, uint64(m.State)) + i-- + dAtA[i] = 0x10 + } + if len(m.Id) > 0 { + i -= len(m.Id) + copy(dAtA[i:], m.Id) + i = encodeVarintTaskQueues(dAtA, i, uint64(len(m.Id))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *CompatibleVersionSet) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *CompatibleVersionSet) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *CompatibleVersionSet) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.DefaultUpdateTimestamp != nil { + { + size, err := m.DefaultUpdateTimestamp.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTaskQueues(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + } + if len(m.BuildIds) > 0 { + for iNdEx := len(m.BuildIds) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.BuildIds[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTaskQueues(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + } + if len(m.SetIds) > 0 { + for iNdEx := len(m.SetIds) - 1; iNdEx >= 0; iNdEx-- { + i -= len(m.SetIds[iNdEx]) + copy(dAtA[i:], m.SetIds[iNdEx]) + i = encodeVarintTaskQueues(dAtA, i, uint64(len(m.SetIds[iNdEx]))) + i-- + dAtA[i] = 0xa + } + } + return len(dAtA) - i, nil +} + +func (m *VersioningData) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *VersioningData) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *VersioningData) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.DefaultUpdateTimestamp != nil { + { + size, err := m.DefaultUpdateTimestamp.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTaskQueues(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + if len(m.VersionSets) > 0 { + for iNdEx := len(m.VersionSets) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.VersionSets[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTaskQueues(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + } + return len(dAtA) - i, nil +} + +func (m *TaskQueueUserData) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *TaskQueueUserData) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *TaskQueueUserData) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.VersioningData != nil { + { + size, err := m.VersioningData.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTaskQueues(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + if m.Clock != nil { + { + size, err := m.Clock.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTaskQueues(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *VersionedTaskQueueUserData) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *VersionedTaskQueueUserData) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *VersionedTaskQueueUserData) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Version != 0 { + i = encodeVarintTaskQueues(dAtA, i, uint64(m.Version)) + i-- + dAtA[i] = 0x10 + } + if m.Data != nil { + { + size, err := m.Data.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTaskQueues(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func encodeVarintTaskQueues(dAtA []byte, offset int, v uint64) int { + offset -= sovTaskQueues(v) + base := offset + for v >= 1<<7 { + dAtA[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + dAtA[offset] = uint8(v) + return base +} +func (m *BuildID) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Id) + if l > 0 { + n += 1 + l + sovTaskQueues(uint64(l)) + } + if m.State != 0 { + n += 1 + sovTaskQueues(uint64(m.State)) + } + if m.StateUpdateTimestamp != nil { + l = m.StateUpdateTimestamp.Size() + n += 1 + l + sovTaskQueues(uint64(l)) + } + return n +} + +func (m *CompatibleVersionSet) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.SetIds) > 0 { + for _, s := range m.SetIds { + l = len(s) + n += 1 + l + sovTaskQueues(uint64(l)) + } + } + if len(m.BuildIds) > 0 { + for _, e := range m.BuildIds { + l = e.Size() + n += 1 + l + sovTaskQueues(uint64(l)) + } + } + if m.DefaultUpdateTimestamp != nil { + l = m.DefaultUpdateTimestamp.Size() + n += 1 + l + sovTaskQueues(uint64(l)) + } + return n +} + +func (m *VersioningData) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.VersionSets) > 0 { + for _, e := range m.VersionSets { + l = e.Size() + n += 1 + l + sovTaskQueues(uint64(l)) + } + } + if m.DefaultUpdateTimestamp != nil { + l = m.DefaultUpdateTimestamp.Size() + n += 1 + l + sovTaskQueues(uint64(l)) + } + return n +} + +func (m *TaskQueueUserData) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Clock != nil { + l = m.Clock.Size() + n += 1 + l + sovTaskQueues(uint64(l)) + } + if m.VersioningData != nil { + l = m.VersioningData.Size() + n += 1 + l + sovTaskQueues(uint64(l)) + } + return n +} + +func (m *VersionedTaskQueueUserData) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Data != nil { + l = m.Data.Size() + n += 1 + l + sovTaskQueues(uint64(l)) + } + if m.Version != 0 { + n += 1 + sovTaskQueues(uint64(m.Version)) + } + return n +} + +func sovTaskQueues(x uint64) (n int) { + return (math_bits.Len64(x|1) + 6) / 7 +} +func sozTaskQueues(x uint64) (n int) { + return sovTaskQueues(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (this *BuildID) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&BuildID{`, + `Id:` + fmt.Sprintf("%v", this.Id) + `,`, + `State:` + fmt.Sprintf("%v", this.State) + `,`, + `StateUpdateTimestamp:` + strings.Replace(fmt.Sprintf("%v", this.StateUpdateTimestamp), "HybridLogicalClock", "v1.HybridLogicalClock", 1) + `,`, + `}`, + }, "") + return s +} +func (this *CompatibleVersionSet) String() string { + if this == nil { + return "nil" + } + repeatedStringForBuildIds := "[]*BuildID{" + for _, f := range this.BuildIds { + repeatedStringForBuildIds += strings.Replace(f.String(), "BuildID", "BuildID", 1) + "," + } + repeatedStringForBuildIds += "}" + s := strings.Join([]string{`&CompatibleVersionSet{`, + `SetIds:` + fmt.Sprintf("%v", this.SetIds) + `,`, + `BuildIds:` + repeatedStringForBuildIds + `,`, + `DefaultUpdateTimestamp:` + strings.Replace(fmt.Sprintf("%v", this.DefaultUpdateTimestamp), "HybridLogicalClock", "v1.HybridLogicalClock", 1) + `,`, + `}`, + }, "") + return s +} +func (this *VersioningData) String() string { + if this == nil { + return "nil" + } + repeatedStringForVersionSets := "[]*CompatibleVersionSet{" + for _, f := range this.VersionSets { + repeatedStringForVersionSets += strings.Replace(f.String(), "CompatibleVersionSet", "CompatibleVersionSet", 1) + "," + } + repeatedStringForVersionSets += "}" + s := strings.Join([]string{`&VersioningData{`, + `VersionSets:` + repeatedStringForVersionSets + `,`, + `DefaultUpdateTimestamp:` + strings.Replace(fmt.Sprintf("%v", this.DefaultUpdateTimestamp), "HybridLogicalClock", "v1.HybridLogicalClock", 1) + `,`, + `}`, + }, "") + return s +} +func (this *TaskQueueUserData) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&TaskQueueUserData{`, + `Clock:` + strings.Replace(fmt.Sprintf("%v", this.Clock), "HybridLogicalClock", "v1.HybridLogicalClock", 1) + `,`, + `VersioningData:` + strings.Replace(this.VersioningData.String(), "VersioningData", "VersioningData", 1) + `,`, + `}`, + }, "") + return s +} +func (this *VersionedTaskQueueUserData) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&VersionedTaskQueueUserData{`, + `Data:` + strings.Replace(this.Data.String(), "TaskQueueUserData", "TaskQueueUserData", 1) + `,`, + `Version:` + fmt.Sprintf("%v", this.Version) + `,`, + `}`, + }, "") + return s +} +func valueToStringTaskQueues(v interface{}) string { + rv := reflect.ValueOf(v) + if rv.IsNil() { + return "nil" + } + pv := reflect.Indirect(rv).Interface() + return fmt.Sprintf("*%v", pv) +} +func (m *BuildID) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTaskQueues + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: BuildID: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: BuildID: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTaskQueues + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthTaskQueues + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTaskQueues + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Id = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field State", wireType) + } + m.State = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTaskQueues + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.State |= BuildID_State(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field StateUpdateTimestamp", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTaskQueues + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTaskQueues + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthTaskQueues + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.StateUpdateTimestamp == nil { + m.StateUpdateTimestamp = &v1.HybridLogicalClock{} + } + if err := m.StateUpdateTimestamp.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipTaskQueues(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthTaskQueues + } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthTaskQueues + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *CompatibleVersionSet) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTaskQueues + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: CompatibleVersionSet: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: CompatibleVersionSet: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SetIds", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTaskQueues + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthTaskQueues + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTaskQueues + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.SetIds = append(m.SetIds, string(dAtA[iNdEx:postIndex])) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field BuildIds", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTaskQueues + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTaskQueues + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthTaskQueues + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.BuildIds = append(m.BuildIds, &BuildID{}) + if err := m.BuildIds[len(m.BuildIds)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field DefaultUpdateTimestamp", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTaskQueues + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTaskQueues + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthTaskQueues + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.DefaultUpdateTimestamp == nil { + m.DefaultUpdateTimestamp = &v1.HybridLogicalClock{} + } + if err := m.DefaultUpdateTimestamp.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipTaskQueues(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthTaskQueues + } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthTaskQueues + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *VersioningData) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTaskQueues + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: VersioningData: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: VersioningData: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field VersionSets", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTaskQueues + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTaskQueues + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthTaskQueues + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.VersionSets = append(m.VersionSets, &CompatibleVersionSet{}) + if err := m.VersionSets[len(m.VersionSets)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field DefaultUpdateTimestamp", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTaskQueues + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTaskQueues + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthTaskQueues + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.DefaultUpdateTimestamp == nil { + m.DefaultUpdateTimestamp = &v1.HybridLogicalClock{} + } + if err := m.DefaultUpdateTimestamp.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipTaskQueues(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthTaskQueues + } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthTaskQueues + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *TaskQueueUserData) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTaskQueues + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: TaskQueueUserData: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: TaskQueueUserData: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Clock", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTaskQueues + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTaskQueues + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthTaskQueues + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Clock == nil { + m.Clock = &v1.HybridLogicalClock{} + } + if err := m.Clock.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field VersioningData", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTaskQueues + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTaskQueues + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthTaskQueues + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.VersioningData == nil { + m.VersioningData = &VersioningData{} + } + if err := m.VersioningData.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipTaskQueues(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthTaskQueues + } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthTaskQueues + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *VersionedTaskQueueUserData) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTaskQueues + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: VersionedTaskQueueUserData: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: VersionedTaskQueueUserData: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTaskQueues + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTaskQueues + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthTaskQueues + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Data == nil { + m.Data = &TaskQueueUserData{} + } + if err := m.Data.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType) + } + m.Version = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTaskQueues + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Version |= int64(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipTaskQueues(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthTaskQueues + } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthTaskQueues + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipTaskQueues(dAtA []byte) (n int, err error) { + l := len(dAtA) + iNdEx := 0 + depth := 0 + for iNdEx < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowTaskQueues + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + wireType := int(wire & 0x7) + switch wireType { + case 0: + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowTaskQueues + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + iNdEx++ + if dAtA[iNdEx-1] < 0x80 { + break + } + } + case 1: + iNdEx += 8 + case 2: + var length int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowTaskQueues + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + length |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if length < 0 { + return 0, ErrInvalidLengthTaskQueues + } + iNdEx += length + case 3: + depth++ + case 4: + if depth == 0 { + return 0, ErrUnexpectedEndOfGroupTaskQueues + } + depth-- + case 5: + iNdEx += 4 + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + if iNdEx < 0 { + return 0, ErrInvalidLengthTaskQueues + } + if depth == 0 { + return iNdEx, nil + } + } + return 0, io.ErrUnexpectedEOF +} + +var ( + ErrInvalidLengthTaskQueues = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowTaskQueues = fmt.Errorf("proto: integer overflow") + ErrUnexpectedEndOfGroupTaskQueues = fmt.Errorf("proto: unexpected end of group") +) diff --git a/api/persistence/v1/tasks.pb.go b/api/persistence/v1/tasks.pb.go index fe6b71b85a5..e26f75dad9f 100644 --- a/api/persistence/v1/tasks.pb.go +++ b/api/persistence/v1/tasks.pb.go @@ -41,7 +41,6 @@ import ( _ "github.com/gogo/protobuf/types" github_com_gogo_protobuf_types "github.com/gogo/protobuf/types" v11 "go.temporal.io/api/enums/v1" - v12 "go.temporal.io/api/taskqueue/v1" v1 "go.temporal.io/server/api/clock/v1" ) @@ -209,7 +208,6 @@ type TaskQueueInfo struct { AckLevel int64 `protobuf:"varint,5,opt,name=ack_level,json=ackLevel,proto3" json:"ack_level,omitempty"` ExpiryTime *time.Time `protobuf:"bytes,6,opt,name=expiry_time,json=expiryTime,proto3,stdtime" json:"expiry_time,omitempty"` LastUpdateTime *time.Time `protobuf:"bytes,7,opt,name=last_update_time,json=lastUpdateTime,proto3,stdtime" json:"last_update_time,omitempty"` - VersioningData *VersioningData `protobuf:"bytes,8,opt,name=versioning_data,json=versioningData,proto3" json:"versioning_data,omitempty"` } func (m *TaskQueueInfo) Reset() { *m = TaskQueueInfo{} } @@ -293,58 +291,6 @@ func (m *TaskQueueInfo) GetLastUpdateTime() *time.Time { return nil } -func (m *TaskQueueInfo) GetVersioningData() *VersioningData { - if m != nil { - return m.VersioningData - } - return nil -} - -// Holds all the data related to worker versioning for a task queue. -// Backwards-incompatible changes cannot be made, as this would make existing stored data unreadable -type VersioningData struct { - VersionSets []*v12.CompatibleVersionSet `protobuf:"bytes,1,rep,name=version_sets,json=versionSets,proto3" json:"version_sets,omitempty"` -} - -func (m *VersioningData) Reset() { *m = VersioningData{} } -func (*VersioningData) ProtoMessage() {} -func (*VersioningData) Descriptor() ([]byte, []int) { - return fileDescriptor_f9c734e3b35cf986, []int{3} -} -func (m *VersioningData) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *VersioningData) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_VersioningData.Marshal(b, m, deterministic) - } else { - b = b[:cap(b)] - n, err := m.MarshalToSizedBuffer(b) - if err != nil { - return nil, err - } - return b[:n], nil - } -} -func (m *VersioningData) XXX_Merge(src proto.Message) { - xxx_messageInfo_VersioningData.Merge(m, src) -} -func (m *VersioningData) XXX_Size() int { - return m.Size() -} -func (m *VersioningData) XXX_DiscardUnknown() { - xxx_messageInfo_VersioningData.DiscardUnknown(m) -} - -var xxx_messageInfo_VersioningData proto.InternalMessageInfo - -func (m *VersioningData) GetVersionSets() []*v12.CompatibleVersionSet { - if m != nil { - return m.VersionSets - } - return nil -} - type TaskKey struct { FireTime *time.Time `protobuf:"bytes,1,opt,name=fire_time,json=fireTime,proto3,stdtime" json:"fire_time,omitempty"` TaskId int64 `protobuf:"varint,2,opt,name=task_id,json=taskId,proto3" json:"task_id,omitempty"` @@ -353,7 +299,7 @@ type TaskKey struct { func (m *TaskKey) Reset() { *m = TaskKey{} } func (*TaskKey) ProtoMessage() {} func (*TaskKey) Descriptor() ([]byte, []int) { - return fileDescriptor_f9c734e3b35cf986, []int{4} + return fileDescriptor_f9c734e3b35cf986, []int{3} } func (m *TaskKey) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -400,7 +346,6 @@ func init() { proto.RegisterType((*AllocatedTaskInfo)(nil), "temporal.server.api.persistence.v1.AllocatedTaskInfo") proto.RegisterType((*TaskInfo)(nil), "temporal.server.api.persistence.v1.TaskInfo") proto.RegisterType((*TaskQueueInfo)(nil), "temporal.server.api.persistence.v1.TaskQueueInfo") - proto.RegisterType((*VersioningData)(nil), "temporal.server.api.persistence.v1.VersioningData") proto.RegisterType((*TaskKey)(nil), "temporal.server.api.persistence.v1.TaskKey") } @@ -409,52 +354,46 @@ func init() { } var fileDescriptor_f9c734e3b35cf986 = []byte{ - // 705 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x54, 0xcd, 0x6e, 0xd3, 0x4c, - 0x14, 0x8d, 0x9b, 0x34, 0x3f, 0x93, 0x7e, 0xf9, 0xca, 0x48, 0x88, 0xa8, 0x48, 0x6e, 0x1b, 0x21, - 0x28, 0xa8, 0xb2, 0xd5, 0xc0, 0x02, 0x09, 0x21, 0x68, 0x0b, 0x8b, 0x50, 0x36, 0x98, 0xd2, 0x05, - 0x2c, 0xa2, 0xa9, 0xe7, 0x26, 0x98, 0xd8, 0x33, 0xc6, 0x33, 0x76, 0xc9, 0x8e, 0x47, 0xe8, 0x63, - 0xf0, 0x28, 0x2c, 0x58, 0x74, 0x59, 0xb1, 0x81, 0xba, 0x1b, 0x96, 0x7d, 0x04, 0x34, 0xe3, 0xd8, - 0x6d, 0x44, 0x2b, 0xb2, 0x60, 0x37, 0x77, 0xee, 0x39, 0x67, 0xee, 0x9c, 0xe3, 0x31, 0xb2, 0x24, - 0x04, 0x21, 0x8f, 0x88, 0x6f, 0x0b, 0x88, 0x12, 0x88, 0x6c, 0x12, 0x7a, 0x76, 0x08, 0x91, 0xf0, - 0x84, 0x04, 0xe6, 0x82, 0x9d, 0x6c, 0xd8, 0x92, 0x88, 0x91, 0xb0, 0xc2, 0x88, 0x4b, 0x8e, 0x3b, - 0x39, 0xde, 0xca, 0xf0, 0x16, 0x09, 0x3d, 0xeb, 0x02, 0xde, 0x4a, 0x36, 0x96, 0x96, 0x87, 0x9c, - 0x0f, 0x7d, 0xb0, 0x35, 0x63, 0x3f, 0x1e, 0xd8, 0xd2, 0x0b, 0x40, 0x48, 0x12, 0x84, 0x99, 0xc8, - 0xd2, 0x2a, 0x85, 0x10, 0x18, 0x05, 0xe6, 0x7a, 0x20, 0xec, 0x21, 0x1f, 0x72, 0xbd, 0xaf, 0x57, - 0x13, 0xc8, 0xed, 0x62, 0x2e, 0x35, 0x10, 0xb0, 0x38, 0x10, 0xf9, 0x28, 0xfd, 0x8f, 0x31, 0xc4, - 0x30, 0xc1, 0xdd, 0x99, 0xc2, 0xa9, 0xb6, 0xee, 0x2a, 0x6c, 0x00, 0x42, 0x90, 0x61, 0x0e, 0xbc, - 0x77, 0xd9, 0x45, 0x5d, 0x9f, 0xbb, 0xa3, 0x3f, 0xb0, 0x1d, 0x86, 0xae, 0x6d, 0xfa, 0x3e, 0x77, - 0x89, 0x04, 0xba, 0x4b, 0xc4, 0xa8, 0xc7, 0x06, 0x1c, 0x3f, 0x45, 0x15, 0x4a, 0x24, 0x69, 0x1b, - 0x2b, 0xc6, 0x5a, 0xb3, 0xbb, 0x6e, 0xfd, 0xdd, 0x08, 0x2b, 0xe7, 0x3a, 0x9a, 0x89, 0x6f, 0xa0, - 0x9a, 0x9e, 0xdf, 0xa3, 0xed, 0xb9, 0x15, 0x63, 0xad, 0xec, 0x54, 0x55, 0xd9, 0xa3, 0x9d, 0xef, - 0x73, 0xa8, 0x5e, 0x9c, 0xb3, 0x8a, 0x16, 0x18, 0x09, 0x40, 0x84, 0xc4, 0x05, 0x05, 0x55, 0xe7, - 0x35, 0x9c, 0x66, 0xb1, 0xd7, 0xa3, 0x78, 0x19, 0x35, 0x0f, 0x78, 0x34, 0x1a, 0xf8, 0xfc, 0x20, - 0x17, 0x6b, 0x38, 0x28, 0xdf, 0xea, 0x51, 0x7c, 0x1d, 0x55, 0xa3, 0x98, 0xa9, 0x5e, 0x59, 0xf7, - 0xe6, 0xa3, 0x98, 0xf5, 0x28, 0x5e, 0x47, 0x58, 0xb8, 0xef, 0x81, 0xc6, 0x3e, 0xd0, 0x3e, 0x24, - 0xc0, 0xa4, 0x82, 0x54, 0xf4, 0x2c, 0x8b, 0x45, 0xe7, 0xb9, 0x6a, 0xf4, 0x28, 0xde, 0x44, 0x4d, - 0x37, 0x02, 0x22, 0xa1, 0xaf, 0xf2, 0x6b, 0xcf, 0xeb, 0x7b, 0x2f, 0x59, 0x59, 0xb8, 0x56, 0x1e, - 0xae, 0xb5, 0x9b, 0x87, 0xbb, 0x55, 0x39, 0xfc, 0xb1, 0x6c, 0x38, 0x28, 0x23, 0xa9, 0x6d, 0x25, - 0x01, 0x9f, 0x42, 0x2f, 0x1a, 0x67, 0x12, 0xd5, 0x59, 0x25, 0x32, 0x92, 0x96, 0x78, 0x82, 0xe6, - 0x75, 0x4a, 0xed, 0x9a, 0x26, 0xdf, 0xbd, 0xd4, 0x77, 0x8d, 0x50, 0x8e, 0xef, 0x81, 0x2b, 0x79, - 0xb4, 0xad, 0x4a, 0x27, 0xe3, 0x75, 0xbe, 0x95, 0xd1, 0x7f, 0xca, 0xdc, 0x57, 0xea, 0xbb, 0x98, - 0xd5, 0x61, 0x8c, 0x2a, 0xaa, 0x9c, 0x58, 0xab, 0xd7, 0x78, 0x13, 0x35, 0x74, 0x7c, 0x72, 0x1c, - 0x82, 0xf6, 0xb5, 0xd5, 0xbd, 0x75, 0x3e, 0x8d, 0x1a, 0x43, 0x7f, 0xa6, 0x79, 0xf0, 0xfa, 0xbc, - 0xdd, 0x71, 0x08, 0x4e, 0x5d, 0xd1, 0xd4, 0x0a, 0x3f, 0x44, 0x95, 0x91, 0xc7, 0x32, 0xcb, 0x67, - 0x60, 0xef, 0x78, 0x8c, 0x3a, 0x9a, 0x81, 0x6f, 0xa2, 0x06, 0x71, 0x47, 0x7d, 0x1f, 0x12, 0xf0, - 0x75, 0x14, 0x65, 0xa7, 0x4e, 0xdc, 0xd1, 0x4b, 0x55, 0xff, 0x0b, 0x9b, 0x5f, 0xa0, 0x45, 0x9f, - 0x08, 0xd9, 0x8f, 0x43, 0x5a, 0x24, 0x5e, 0x9b, 0x51, 0xa7, 0xa5, 0x98, 0x6f, 0x34, 0x51, 0x6b, - 0xbd, 0x43, 0xff, 0x27, 0xea, 0x21, 0x70, 0xe6, 0xb1, 0x61, 0x5f, 0x3f, 0x9a, 0xba, 0x96, 0xea, - 0xce, 0xf2, 0x68, 0xf6, 0x0a, 0xea, 0x33, 0x22, 0x89, 0xd3, 0x4a, 0xa6, 0xea, 0x0e, 0x45, 0xad, - 0x69, 0x04, 0x76, 0xd0, 0xc2, 0x04, 0xd3, 0x17, 0x20, 0x45, 0xdb, 0x58, 0x29, 0xaf, 0x35, 0xbb, - 0xf6, 0xb4, 0xb9, 0xc5, 0x9f, 0x41, 0x1d, 0xb1, 0xcd, 0x83, 0x90, 0x48, 0x6f, 0xdf, 0x87, 0x89, - 0xd4, 0x6b, 0x90, 0x4e, 0x33, 0x29, 0xd6, 0xa2, 0x43, 0x50, 0x4d, 0xa5, 0xb0, 0x03, 0x63, 0xfc, - 0x18, 0x35, 0x06, 0x5e, 0x34, 0xb1, 0xc4, 0x98, 0xd1, 0x92, 0xba, 0xa2, 0x68, 0x33, 0xae, 0x7a, - 0xf4, 0x5b, 0x1f, 0x8e, 0x4e, 0xcc, 0xd2, 0xf1, 0x89, 0x59, 0x3a, 0x3b, 0x31, 0x8d, 0xcf, 0xa9, - 0x69, 0x7c, 0x49, 0x4d, 0xe3, 0x6b, 0x6a, 0x1a, 0x47, 0xa9, 0x69, 0xfc, 0x4c, 0x4d, 0xe3, 0x57, - 0x6a, 0x96, 0xce, 0x52, 0xd3, 0x38, 0x3c, 0x35, 0x4b, 0x47, 0xa7, 0x66, 0xe9, 0xf8, 0xd4, 0x2c, - 0xbd, 0x7d, 0x30, 0xe4, 0xe7, 0x17, 0xf3, 0xf8, 0xd5, 0x7f, 0xed, 0x47, 0x17, 0xca, 0xfd, 0xaa, - 0x1e, 0xf4, 0xfe, 0xef, 0x00, 0x00, 0x00, 0xff, 0xff, 0xac, 0xd4, 0xe2, 0x22, 0xee, 0x05, 0x00, - 0x00, + // 619 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x54, 0x4f, 0x6f, 0xd3, 0x30, + 0x1c, 0x6d, 0xb6, 0xae, 0x7f, 0x5c, 0x98, 0x86, 0x25, 0x44, 0x35, 0x24, 0x6f, 0xab, 0x10, 0x1a, + 0x68, 0x4a, 0xb4, 0xc1, 0x01, 0x09, 0x21, 0xd8, 0x10, 0x87, 0x32, 0x2e, 0x44, 0x83, 0x03, 0x97, + 0xca, 0x8b, 0x7f, 0x2d, 0x21, 0x69, 0x1c, 0x6c, 0xa7, 0xa3, 0x37, 0x3e, 0xc2, 0x3e, 0x06, 0x1f, + 0x85, 0xe3, 0x8e, 0x13, 0x17, 0x58, 0x7a, 0xe1, 0xc6, 0x3e, 0x02, 0xfa, 0x39, 0x4d, 0xb7, 0xc3, + 0x26, 0x7a, 0xe0, 0x66, 0xfb, 0xf7, 0xde, 0xf3, 0xf3, 0x7b, 0x69, 0x89, 0x6b, 0x60, 0x98, 0x4a, + 0xc5, 0x63, 0x4f, 0x83, 0x1a, 0x81, 0xf2, 0x78, 0x1a, 0x7a, 0x29, 0x28, 0x1d, 0x6a, 0x03, 0x49, + 0x00, 0xde, 0x68, 0xdb, 0x33, 0x5c, 0x47, 0xda, 0x4d, 0x95, 0x34, 0x92, 0x76, 0x4a, 0xbc, 0x5b, + 0xe0, 0x5d, 0x9e, 0x86, 0xee, 0x25, 0xbc, 0x3b, 0xda, 0x5e, 0x5d, 0x1b, 0x48, 0x39, 0x88, 0xc1, + 0xb3, 0x8c, 0xc3, 0xac, 0xef, 0x99, 0x70, 0x08, 0xda, 0xf0, 0x61, 0x5a, 0x88, 0xac, 0x6e, 0x08, + 0x48, 0x21, 0x11, 0x90, 0x04, 0x21, 0x68, 0x6f, 0x20, 0x07, 0xd2, 0x9e, 0xdb, 0xd5, 0x14, 0x72, + 0x7f, 0xe6, 0x0b, 0x0d, 0x41, 0x92, 0x0d, 0x75, 0x69, 0xa5, 0xf7, 0x39, 0x83, 0x0c, 0xa6, 0xb8, + 0x87, 0x57, 0xf9, 0x0f, 0x62, 0x19, 0x44, 0x08, 0x1f, 0x82, 0xd6, 0x7c, 0x30, 0xc5, 0x76, 0x12, + 0x72, 0x6b, 0x37, 0x8e, 0x65, 0xc0, 0x0d, 0x88, 0x03, 0xae, 0xa3, 0x6e, 0xd2, 0x97, 0xf4, 0x05, + 0xa9, 0x0a, 0x6e, 0x78, 0xdb, 0x59, 0x77, 0x36, 0x5b, 0x3b, 0x5b, 0xee, 0xbf, 0xdf, 0xe7, 0x96, + 0x5c, 0xdf, 0x32, 0xe9, 0x1d, 0x52, 0xb7, 0xb6, 0x42, 0xd1, 0x5e, 0x58, 0x77, 0x36, 0x17, 0xfd, + 0x1a, 0x6e, 0xbb, 0xa2, 0xf3, 0x63, 0x81, 0x34, 0x66, 0xf7, 0x6c, 0x90, 0x1b, 0x09, 0x1f, 0x82, + 0x4e, 0x79, 0x00, 0x08, 0xc5, 0xfb, 0x9a, 0x7e, 0x6b, 0x76, 0xd6, 0x15, 0x74, 0x8d, 0xb4, 0x8e, + 0xa4, 0x8a, 0xfa, 0xb1, 0x3c, 0x2a, 0xc5, 0x9a, 0x3e, 0x29, 0x8f, 0xba, 0x82, 0xde, 0x26, 0x35, + 0x95, 0x25, 0x38, 0x5b, 0xb4, 0xb3, 0x25, 0x95, 0x25, 0x5d, 0x41, 0xb7, 0x08, 0xd5, 0xc1, 0x47, + 0x10, 0x59, 0x0c, 0xa2, 0x07, 0x23, 0x48, 0x0c, 0x42, 0xaa, 0xd6, 0xcb, 0xca, 0x6c, 0xf2, 0x0a, + 0x07, 0x5d, 0x41, 0x77, 0x49, 0x2b, 0x50, 0xc0, 0x0d, 0xf4, 0xb0, 0x96, 0xf6, 0x92, 0x7d, 0xf7, + 0xaa, 0x5b, 0x74, 0xe6, 0x96, 0x9d, 0xb9, 0x07, 0x65, 0x67, 0x7b, 0xd5, 0xe3, 0x9f, 0x6b, 0x8e, + 0x4f, 0x0a, 0x12, 0x1e, 0xa3, 0x04, 0x7c, 0x49, 0x43, 0x35, 0x2e, 0x24, 0x6a, 0xf3, 0x4a, 0x14, + 0x24, 0x2b, 0xf1, 0x9c, 0x2c, 0xd9, 0x96, 0xda, 0x75, 0x4b, 0x7e, 0x70, 0x65, 0xee, 0x16, 0x81, + 0x89, 0xbf, 0x87, 0xc0, 0x48, 0xf5, 0x12, 0xb7, 0x7e, 0xc1, 0xeb, 0xfc, 0x59, 0x20, 0x37, 0x31, + 0xdc, 0xb7, 0xf8, 0x31, 0xcc, 0x9b, 0x30, 0x25, 0x55, 0xdc, 0x4e, 0xa3, 0xb5, 0x6b, 0xba, 0x4b, + 0x9a, 0xb6, 0x3e, 0x33, 0x4e, 0xc1, 0xe6, 0xba, 0xbc, 0x73, 0xef, 0xc2, 0x0d, 0xda, 0xb0, 0x5f, + 0x5f, 0x59, 0xbc, 0xbd, 0xef, 0x60, 0x9c, 0x82, 0xdf, 0x40, 0x1a, 0xae, 0xe8, 0x13, 0x52, 0x8d, + 0xc2, 0xa4, 0x88, 0x7c, 0x0e, 0xf6, 0x7e, 0x98, 0x08, 0xdf, 0x32, 0xe8, 0x5d, 0xd2, 0xe4, 0x41, + 0xd4, 0x8b, 0x61, 0x04, 0xb1, 0xad, 0x62, 0xd1, 0x6f, 0xf0, 0x20, 0x7a, 0x83, 0xfb, 0xff, 0x11, + 0xf3, 0x6b, 0xb2, 0x12, 0x73, 0x6d, 0x7a, 0x59, 0x2a, 0x66, 0x8d, 0xd7, 0xe7, 0xd4, 0x59, 0x46, + 0xe6, 0x3b, 0x4b, 0xc4, 0x51, 0x87, 0x93, 0x3a, 0x3e, 0x61, 0x1f, 0xc6, 0xf4, 0x19, 0x69, 0xf6, + 0x43, 0x35, 0xd5, 0x73, 0xe6, 0xd4, 0x6b, 0x20, 0xc5, 0xba, 0xba, 0xee, 0x17, 0xb3, 0xf7, 0xe9, + 0xe4, 0x8c, 0x55, 0x4e, 0xcf, 0x58, 0xe5, 0xfc, 0x8c, 0x39, 0x5f, 0x73, 0xe6, 0x7c, 0xcb, 0x99, + 0xf3, 0x3d, 0x67, 0xce, 0x49, 0xce, 0x9c, 0x5f, 0x39, 0x73, 0x7e, 0xe7, 0xac, 0x72, 0x9e, 0x33, + 0xe7, 0x78, 0xc2, 0x2a, 0x27, 0x13, 0x56, 0x39, 0x9d, 0xb0, 0xca, 0x87, 0xc7, 0x03, 0x79, 0x11, + 0x79, 0x28, 0xaf, 0xff, 0x27, 0x7b, 0x7a, 0x69, 0x7b, 0x58, 0xb3, 0x46, 0x1f, 0xfd, 0x0d, 0x00, + 0x00, 0xff, 0xff, 0x86, 0xf6, 0x0e, 0x01, 0x02, 0x05, 0x00, 0x00, } func (this *AllocatedTaskInfo) Equal(that interface{}) bool { @@ -582,38 +521,6 @@ func (this *TaskQueueInfo) Equal(that interface{}) bool { } else if !this.LastUpdateTime.Equal(*that1.LastUpdateTime) { return false } - if !this.VersioningData.Equal(that1.VersioningData) { - return false - } - return true -} -func (this *VersioningData) Equal(that interface{}) bool { - if that == nil { - return this == nil - } - - that1, ok := that.(*VersioningData) - if !ok { - that2, ok := that.(VersioningData) - if ok { - that1 = &that2 - } else { - return false - } - } - if that1 == nil { - return this == nil - } else if this == nil { - return false - } - if len(this.VersionSets) != len(that1.VersionSets) { - return false - } - for i := range this.VersionSets { - if !this.VersionSets[i].Equal(that1.VersionSets[i]) { - return false - } - } return true } func (this *TaskKey) Equal(that interface{}) bool { @@ -682,7 +589,7 @@ func (this *TaskQueueInfo) GoString() string { if this == nil { return "nil" } - s := make([]string, 0, 12) + s := make([]string, 0, 11) s = append(s, "&persistence.TaskQueueInfo{") s = append(s, "NamespaceId: "+fmt.Sprintf("%#v", this.NamespaceId)+",\n") s = append(s, "Name: "+fmt.Sprintf("%#v", this.Name)+",\n") @@ -691,21 +598,6 @@ func (this *TaskQueueInfo) GoString() string { s = append(s, "AckLevel: "+fmt.Sprintf("%#v", this.AckLevel)+",\n") s = append(s, "ExpiryTime: "+fmt.Sprintf("%#v", this.ExpiryTime)+",\n") s = append(s, "LastUpdateTime: "+fmt.Sprintf("%#v", this.LastUpdateTime)+",\n") - if this.VersioningData != nil { - s = append(s, "VersioningData: "+fmt.Sprintf("%#v", this.VersioningData)+",\n") - } - s = append(s, "}") - return strings.Join(s, "") -} -func (this *VersioningData) GoString() string { - if this == nil { - return "nil" - } - s := make([]string, 0, 5) - s = append(s, "&persistence.VersioningData{") - if this.VersionSets != nil { - s = append(s, "VersionSets: "+fmt.Sprintf("%#v", this.VersionSets)+",\n") - } s = append(s, "}") return strings.Join(s, "") } @@ -869,36 +761,24 @@ func (m *TaskQueueInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) { _ = i var l int _ = l - if m.VersioningData != nil { - { - size, err := m.VersioningData.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintTasks(dAtA, i, uint64(size)) + if m.LastUpdateTime != nil { + n5, err5 := github_com_gogo_protobuf_types.StdTimeMarshalTo(*m.LastUpdateTime, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(*m.LastUpdateTime):]) + if err5 != nil { + return 0, err5 } + i -= n5 + i = encodeVarintTasks(dAtA, i, uint64(n5)) i-- - dAtA[i] = 0x42 + dAtA[i] = 0x3a } - if m.LastUpdateTime != nil { - n6, err6 := github_com_gogo_protobuf_types.StdTimeMarshalTo(*m.LastUpdateTime, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(*m.LastUpdateTime):]) + if m.ExpiryTime != nil { + n6, err6 := github_com_gogo_protobuf_types.StdTimeMarshalTo(*m.ExpiryTime, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(*m.ExpiryTime):]) if err6 != nil { return 0, err6 } i -= n6 i = encodeVarintTasks(dAtA, i, uint64(n6)) i-- - dAtA[i] = 0x3a - } - if m.ExpiryTime != nil { - n7, err7 := github_com_gogo_protobuf_types.StdTimeMarshalTo(*m.ExpiryTime, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(*m.ExpiryTime):]) - if err7 != nil { - return 0, err7 - } - i -= n7 - i = encodeVarintTasks(dAtA, i, uint64(n7)) - i-- dAtA[i] = 0x32 } if m.AckLevel != 0 { @@ -933,43 +813,6 @@ func (m *TaskQueueInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) { return len(dAtA) - i, nil } -func (m *VersioningData) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { - return nil, err - } - return dAtA[:n], nil -} - -func (m *VersioningData) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *VersioningData) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if len(m.VersionSets) > 0 { - for iNdEx := len(m.VersionSets) - 1; iNdEx >= 0; iNdEx-- { - { - size, err := m.VersionSets[iNdEx].MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintTasks(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0xa - } - } - return len(dAtA) - i, nil -} - func (m *TaskKey) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) @@ -996,12 +839,12 @@ func (m *TaskKey) MarshalToSizedBuffer(dAtA []byte) (int, error) { dAtA[i] = 0x10 } if m.FireTime != nil { - n8, err8 := github_com_gogo_protobuf_types.StdTimeMarshalTo(*m.FireTime, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(*m.FireTime):]) - if err8 != nil { - return 0, err8 + n7, err7 := github_com_gogo_protobuf_types.StdTimeMarshalTo(*m.FireTime, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(*m.FireTime):]) + if err7 != nil { + return 0, err7 } - i -= n8 - i = encodeVarintTasks(dAtA, i, uint64(n8)) + i -= n7 + i = encodeVarintTasks(dAtA, i, uint64(n7)) i-- dAtA[i] = 0xa } @@ -1102,25 +945,6 @@ func (m *TaskQueueInfo) Size() (n int) { l = github_com_gogo_protobuf_types.SizeOfStdTime(*m.LastUpdateTime) n += 1 + l + sovTasks(uint64(l)) } - if m.VersioningData != nil { - l = m.VersioningData.Size() - n += 1 + l + sovTasks(uint64(l)) - } - return n -} - -func (m *VersioningData) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if len(m.VersionSets) > 0 { - for _, e := range m.VersionSets { - l = e.Size() - n += 1 + l + sovTasks(uint64(l)) - } - } return n } @@ -1185,22 +1009,6 @@ func (this *TaskQueueInfo) String() string { `AckLevel:` + fmt.Sprintf("%v", this.AckLevel) + `,`, `ExpiryTime:` + strings.Replace(fmt.Sprintf("%v", this.ExpiryTime), "Timestamp", "types.Timestamp", 1) + `,`, `LastUpdateTime:` + strings.Replace(fmt.Sprintf("%v", this.LastUpdateTime), "Timestamp", "types.Timestamp", 1) + `,`, - `VersioningData:` + strings.Replace(this.VersioningData.String(), "VersioningData", "VersioningData", 1) + `,`, - `}`, - }, "") - return s -} -func (this *VersioningData) String() string { - if this == nil { - return "nil" - } - repeatedStringForVersionSets := "[]*CompatibleVersionSet{" - for _, f := range this.VersionSets { - repeatedStringForVersionSets += strings.Replace(fmt.Sprintf("%v", f), "CompatibleVersionSet", "v12.CompatibleVersionSet", 1) + "," - } - repeatedStringForVersionSets += "}" - s := strings.Join([]string{`&VersioningData{`, - `VersionSets:` + repeatedStringForVersionSets + `,`, `}`, }, "") return s @@ -1830,129 +1638,6 @@ func (m *TaskQueueInfo) Unmarshal(dAtA []byte) error { return err } iNdEx = postIndex - case 8: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field VersioningData", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowTasks - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthTasks - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthTasks - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.VersioningData == nil { - m.VersioningData = &VersioningData{} - } - if err := m.VersioningData.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipTasks(dAtA[iNdEx:]) - if err != nil { - return err - } - if skippy < 0 { - return ErrInvalidLengthTasks - } - if (iNdEx + skippy) < 0 { - return ErrInvalidLengthTasks - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *VersioningData) Unmarshal(dAtA []byte) error { - l := len(dAtA) - iNdEx := 0 - for iNdEx < l { - preIndex := iNdEx - var wire uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowTasks - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - wire |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - fieldNum := int32(wire >> 3) - wireType := int(wire & 0x7) - if wireType == 4 { - return fmt.Errorf("proto: VersioningData: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: VersioningData: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field VersionSets", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowTasks - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthTasks - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthTasks - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.VersionSets = append(m.VersionSets, &v12.CompatibleVersionSet{}) - if err := m.VersionSets[len(m.VersionSets)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipTasks(dAtA[iNdEx:]) diff --git a/client/matching/client_gen.go b/client/matching/client_gen.go index ce71c88728c..5bbd74a2f63 100644 --- a/client/matching/client_gen.go +++ b/client/matching/client_gen.go @@ -65,11 +65,11 @@ func (c *clientImpl) DescribeTaskQueue( return client.DescribeTaskQueue(ctx, request, opts...) } -func (c *clientImpl) GetTaskQueueMetadata( +func (c *clientImpl) GetTaskQueueUserData( ctx context.Context, - request *matchingservice.GetTaskQueueMetadataRequest, + request *matchingservice.GetTaskQueueUserDataRequest, opts ...grpc.CallOption, -) (*matchingservice.GetTaskQueueMetadataResponse, error) { +) (*matchingservice.GetTaskQueueUserDataResponse, error) { client, err := c.getClientForTaskqueue(request.GetNamespaceId(), &taskqueuepb.TaskQueue{Name: request.GetTaskQueue()}, enumspb.TASK_QUEUE_TYPE_WORKFLOW) if err != nil { @@ -77,7 +77,7 @@ func (c *clientImpl) GetTaskQueueMetadata( } ctx, cancel := c.createContext(ctx) defer cancel() - return client.GetTaskQueueMetadata(ctx, request, opts...) + return client.GetTaskQueueUserData(ctx, request, opts...) } func (c *clientImpl) GetWorkerBuildIdCompatibility( @@ -95,11 +95,11 @@ func (c *clientImpl) GetWorkerBuildIdCompatibility( return client.GetWorkerBuildIdCompatibility(ctx, request, opts...) } -func (c *clientImpl) InvalidateTaskQueueMetadata( +func (c *clientImpl) InvalidateTaskQueueUserData( ctx context.Context, - request *matchingservice.InvalidateTaskQueueMetadataRequest, + request *matchingservice.InvalidateTaskQueueUserDataRequest, opts ...grpc.CallOption, -) (*matchingservice.InvalidateTaskQueueMetadataResponse, error) { +) (*matchingservice.InvalidateTaskQueueUserDataResponse, error) { client, err := c.getClientForTaskqueue(request.GetNamespaceId(), &taskqueuepb.TaskQueue{Name: request.GetTaskQueue()}, request.GetTaskQueueType()) if err != nil { @@ -107,7 +107,7 @@ func (c *clientImpl) InvalidateTaskQueueMetadata( } ctx, cancel := c.createContext(ctx) defer cancel() - return client.InvalidateTaskQueueMetadata(ctx, request, opts...) + return client.InvalidateTaskQueueUserData(ctx, request, opts...) } func (c *clientImpl) ListTaskQueuePartitions( diff --git a/client/matching/metric_client_gen.go b/client/matching/metric_client_gen.go index d1861a15028..db0468ceac0 100644 --- a/client/matching/metric_client_gen.go +++ b/client/matching/metric_client_gen.go @@ -63,18 +63,18 @@ func (c *metricClient) DescribeTaskQueue( return c.client.DescribeTaskQueue(ctx, request, opts...) } -func (c *metricClient) GetTaskQueueMetadata( +func (c *metricClient) GetTaskQueueUserData( ctx context.Context, - request *matchingservice.GetTaskQueueMetadataRequest, + request *matchingservice.GetTaskQueueUserDataRequest, opts ...grpc.CallOption, -) (_ *matchingservice.GetTaskQueueMetadataResponse, retError error) { +) (_ *matchingservice.GetTaskQueueUserDataResponse, retError error) { - metricsHandler, startTime := c.startMetricsRecording(ctx, metrics.MatchingClientGetTaskQueueMetadataScope) + metricsHandler, startTime := c.startMetricsRecording(ctx, metrics.MatchingClientGetTaskQueueUserDataScope) defer func() { c.finishMetricsRecording(metricsHandler, startTime, retError) }() - return c.client.GetTaskQueueMetadata(ctx, request, opts...) + return c.client.GetTaskQueueUserData(ctx, request, opts...) } func (c *metricClient) GetWorkerBuildIdCompatibility( @@ -91,18 +91,18 @@ func (c *metricClient) GetWorkerBuildIdCompatibility( return c.client.GetWorkerBuildIdCompatibility(ctx, request, opts...) } -func (c *metricClient) InvalidateTaskQueueMetadata( +func (c *metricClient) InvalidateTaskQueueUserData( ctx context.Context, - request *matchingservice.InvalidateTaskQueueMetadataRequest, + request *matchingservice.InvalidateTaskQueueUserDataRequest, opts ...grpc.CallOption, -) (_ *matchingservice.InvalidateTaskQueueMetadataResponse, retError error) { +) (_ *matchingservice.InvalidateTaskQueueUserDataResponse, retError error) { - metricsHandler, startTime := c.startMetricsRecording(ctx, metrics.MatchingClientInvalidateTaskQueueMetadataScope) + metricsHandler, startTime := c.startMetricsRecording(ctx, metrics.MatchingClientInvalidateTaskQueueUserDataScope) defer func() { c.finishMetricsRecording(metricsHandler, startTime, retError) }() - return c.client.InvalidateTaskQueueMetadata(ctx, request, opts...) + return c.client.InvalidateTaskQueueUserData(ctx, request, opts...) } func (c *metricClient) ListTaskQueuePartitions( diff --git a/client/matching/retryable_client_gen.go b/client/matching/retryable_client_gen.go index f77440e0d91..6d14a77fe4f 100644 --- a/client/matching/retryable_client_gen.go +++ b/client/matching/retryable_client_gen.go @@ -95,15 +95,15 @@ func (c *retryableClient) DescribeTaskQueue( return resp, err } -func (c *retryableClient) GetTaskQueueMetadata( +func (c *retryableClient) GetTaskQueueUserData( ctx context.Context, - request *matchingservice.GetTaskQueueMetadataRequest, + request *matchingservice.GetTaskQueueUserDataRequest, opts ...grpc.CallOption, -) (*matchingservice.GetTaskQueueMetadataResponse, error) { - var resp *matchingservice.GetTaskQueueMetadataResponse +) (*matchingservice.GetTaskQueueUserDataResponse, error) { + var resp *matchingservice.GetTaskQueueUserDataResponse op := func(ctx context.Context) error { var err error - resp, err = c.client.GetTaskQueueMetadata(ctx, request, opts...) + resp, err = c.client.GetTaskQueueUserData(ctx, request, opts...) return err } err := backoff.ThrottleRetryContext(ctx, op, c.policy, c.isRetryable) @@ -125,15 +125,15 @@ func (c *retryableClient) GetWorkerBuildIdCompatibility( return resp, err } -func (c *retryableClient) InvalidateTaskQueueMetadata( +func (c *retryableClient) InvalidateTaskQueueUserData( ctx context.Context, - request *matchingservice.InvalidateTaskQueueMetadataRequest, + request *matchingservice.InvalidateTaskQueueUserDataRequest, opts ...grpc.CallOption, -) (*matchingservice.InvalidateTaskQueueMetadataResponse, error) { - var resp *matchingservice.InvalidateTaskQueueMetadataResponse +) (*matchingservice.InvalidateTaskQueueUserDataResponse, error) { + var resp *matchingservice.InvalidateTaskQueueUserDataResponse op := func(ctx context.Context) error { var err error - resp, err = c.client.InvalidateTaskQueueMetadata(ctx, request, opts...) + resp, err = c.client.InvalidateTaskQueueUserData(ctx, request, opts...) return err } err := backoff.ThrottleRetryContext(ctx, op, c.policy, c.isRetryable) diff --git a/cmd/tools/rpcwrappers/main.go b/cmd/tools/rpcwrappers/main.go index 401d4cdba62..8ad790f465d 100644 --- a/cmd/tools/rpcwrappers/main.go +++ b/cmd/tools/rpcwrappers/main.go @@ -188,7 +188,7 @@ func makeGetMatchingClient(reqType reflect.Type) string { "UpdateWorkerBuildIdCompatibilityRequest", "RespondQueryTaskCompletedRequest", "ListTaskQueuePartitionsRequest", - "GetTaskQueueMetadataRequest": + "GetTaskQueueUserDataRequest": tqtPath = "enumspb.TASK_QUEUE_TYPE_WORKFLOW" default: tqtPath = pathToField(t, "TaskQueueType", "request", 2) diff --git a/common/dynamicconfig/constants.go b/common/dynamicconfig/constants.go index 19ecca0e582..6c1fd9c0e96 100644 --- a/common/dynamicconfig/constants.go +++ b/common/dynamicconfig/constants.go @@ -148,9 +148,14 @@ const ( // WorkerBuildIdSizeLimit is the byte length limit for a worker build id as used in the rpc methods for updating // the version graph for a task queue WorkerBuildIdSizeLimit = "limit.workerBuildIdSize" - // VersionGraphNodeLimit is the max number of nodes allowed in the version graph for a task queue. Update requests - // which would cause the graph size to exceed this number will result in the oldest versions being dropped. - VersionGraphNodeLimit = "limit.versionGraphNodeSize" + // VersionCompatibleSetLimitPerQueue is the max number of compatible sets allowed in the versioning data for a task + // queue. Update requests which would cause the versioning data to exceed this number will fail with a + // FailedPrecondition error. + VersionCompatibleSetLimitPerQueue = "limit.versionCompatibleSetLimitPerQueue" + // VersionBuildIDLimitPerQueue is the max number of build IDs allowed to be defined in the versioning data for a + // task queue. Update requests which would cause the versioning data to exceed this number will fail with a + // FailedPrecondition error. + VersionBuildIDLimitPerQueue = "limit.versionBuildIDLimitPerQueue" // keys for frontend @@ -331,8 +336,8 @@ const ( MatchingForwarderMaxChildrenPerNode = "matching.forwarderMaxChildrenPerNode" // MatchingShutdownDrainDuration is the duration of traffic drain during shutdown MatchingShutdownDrainDuration = "matching.shutdownDrainDuration" - // MatchingMetadataPollFrequency is how often non-root partitions will poll the root partition for fresh metadata - MatchingMetadataPollFrequency = "matching.metadataPollFrequency" + // MatchingUserDataPollFrequency is how often non-root partitions will poll the root partition for fresh metadata + MatchingUserDataPollFrequency = "matching.userDataPollFrequency" // keys for history diff --git a/common/metrics/metric_defs.go b/common/metrics/metric_defs.go index f068f8fe686..ea6cc4e0a59 100644 --- a/common/metrics/metric_defs.go +++ b/common/metrics/metric_defs.go @@ -465,10 +465,10 @@ const ( MatchingClientUpdateWorkerBuildIdCompatibilityScope = "MatchingClientUpdateWorkerBuildIdCompatibility" // MatchingClientGetWorkerBuildIdCompatibilityScope tracks RPC calls to matching service MatchingClientGetWorkerBuildIdCompatibilityScope = "MatchingClientGetWorkerBuildIdCompatibility" - // MatchingClientInvalidateTaskQueueMetadataScope tracks RPC calls to matching service - MatchingClientInvalidateTaskQueueMetadataScope = "MatchingClientInvalidateTaskQueueMetadata" - // MatchingClientGetTaskQueueMetadataScope tracks RPC calls to matching service - MatchingClientGetTaskQueueMetadataScope = "MatchingClientGetTaskQueueMetadata" + // MatchingClientInvalidateTaskQueueUserDataScope tracks RPC calls to matching service + MatchingClientInvalidateTaskQueueUserDataScope = "MatchingClientInvalidateTaskQueueUserData" + // MatchingClientGetTaskQueueUserDataScope tracks RPC calls to matching service + MatchingClientGetTaskQueueUserDataScope = "MatchingClientGetTaskQueueUserData" ) // Worker @@ -628,6 +628,10 @@ const ( PersistenceListTaskQueueScope = "ListTaskQueue" // PersistenceDeleteTaskQueueScope is the metric scope for persistence.TaskManager.DeleteTaskQueue API PersistenceDeleteTaskQueueScope = "DeleteTaskQueue" + // PersistenceGetTaskQueueUserDataScope is the metric scope for persistence.TaskManager.GetTaskQueueUserData API + PersistenceGetTaskQueueUserDataScope = "GetTaskQueueUserData" + // PersistenceUpdateTaskQueueUserDataScope is the metric scope for persistence.TaskManager.UpdateTaskQueueUserData API + PersistenceUpdateTaskQueueUserDataScope = "UpdateTaskQueueUserData" // PersistenceAppendHistoryEventsScope tracks AppendHistoryEvents calls made by service to persistence layer PersistenceAppendHistoryEventsScope = "AppendHistoryEvents" // PersistenceGetWorkflowExecutionHistoryScope tracks GetWorkflowExecutionHistory calls made by service to persistence layer @@ -1096,10 +1100,10 @@ const ( MatchingUpdateWorkerBuildIdCompatibilityScope = "UpdateWorkerBuildIdCompatibility" // MatchingGetWorkerBuildIdCompatibilityScope tracks GetWorkerBuildIdCompatibility API calls received by service MatchingGetWorkerBuildIdCompatibilityScope = "GetWorkerBuildIdCompatibility" - // MatchingInvalidateTaskQueueMetadataScope tracks GetWorkerBuildIdCompatibility API calls received by service - MatchingInvalidateTaskQueueMetadataScope = "InvalidateTaskQueueMetadata" - // MatchingGetTaskQueueMetadataScope tracks GetWorkerBuildIdCompatibility API calls received by service - MatchingGetTaskQueueMetadataScope = "GetTaskQueueMetadata" + // MatchingInvalidateTaskQueueUserDataScope tracks InvalidateTaskQueueUserData API calls received by service + MatchingInvalidateTaskQueueUserDataScope = "InvalidateTaskQueueUserData" + // MatchingGetTaskQueueUserDataScope tracks GetTaskQueueUserData API calls received by service + MatchingGetTaskQueueUserDataScope = "GetTaskQueueUserData" ) // Worker Scope diff --git a/common/persistence/cassandra/matching_task_store.go b/common/persistence/cassandra/matching_task_store.go index ad3a9f7e48d..701f15f4915 100644 --- a/common/persistence/cassandra/matching_task_store.go +++ b/common/persistence/cassandra/matching_task_store.go @@ -131,6 +131,22 @@ const ( `AND type = ? ` + `AND task_id = ? ` + `IF range_id = ?` + + templateGetTaskQueueUserDataQuery = `SELECT data, data_encoding, version FROM task_queue_user_data ` + + `WHERE namespace_id = ? ` + + `AND task_queue_name = ? ` + + templateUpdateTaskQueueUserDataQuery = `UPDATE task_queue_user_data SET ` + + `data = ?, ` + + `data_encoding = ?, ` + + `version = ? ` + + `WHERE namespace_id = ? ` + + `AND task_queue_name = ? ` + + `IF version = ?` + + templateInsertTaskQueueUserDataQuery = `INSERT INTO task_queue_user_data` + + `(namespace_id, task_queue_name, data, data_encoding, version) ` + + `VALUES (?, ?, ?, ?, 1) IF NOT EXISTS` ) type ( @@ -494,6 +510,72 @@ func (d *MatchingTaskStore) CompleteTasksLessThan( return p.UnknownNumRowsAffected, nil } +func (d *MatchingTaskStore) GetTaskQueueUserData( + ctx context.Context, + request *p.GetTaskQueueUserDataRequest, +) (*p.InternalGetTaskQueueUserDataResponse, error) { + query := d.Session.Query(templateGetTaskQueueUserDataQuery, + request.NamespaceID, + request.TaskQueue, + ).WithContext(ctx) + var version int64 + var userDataBytes []byte + var encoding string + if err := query.Scan(&userDataBytes, &encoding, &version); err != nil { + return nil, gocql.ConvertError("GetTaskQueueData", err) + } + + return &p.InternalGetTaskQueueUserDataResponse{ + Version: version, + UserData: p.NewDataBlob(userDataBytes, encoding), + }, nil +} + +func (d *MatchingTaskStore) UpdateTaskQueueUserData( + ctx context.Context, + request *p.InternalUpdateTaskQueueUserDataRequest, +) error { + var query gocql.Query + + if request.Version == 0 { + query = d.Session.Query(templateInsertTaskQueueUserDataQuery, + request.NamespaceID, + request.TaskQueue, + request.UserData.Data, + request.UserData.EncodingType.String(), + ).WithContext(ctx) + } else { + query = d.Session.Query(templateUpdateTaskQueueUserDataQuery, + request.UserData.Data, + request.UserData.EncodingType.String(), + request.Version+1, + request.NamespaceID, + request.TaskQueue, + request.Version, + ).WithContext(ctx) + } + previous := make(map[string]interface{}) + applied, err := query.MapScanCAS(previous) + + if err != nil { + return gocql.ConvertError("UpdateTaskQueueData", err) + } + + if !applied { + var columns []string + for k, v := range previous { + columns = append(columns, fmt.Sprintf("%s=%v", k, v)) + } + + return &p.ConditionFailedError{ + Msg: fmt.Sprintf("Failed to update task queue. name: %v, version: %v, columns: (%v)", + request.TaskQueue, request.Version, strings.Join(columns, ",")), + } + } + + return nil +} + func (d *MatchingTaskStore) GetName() string { return cassandraPersistenceName } diff --git a/common/persistence/client/fault_injection.go b/common/persistence/client/fault_injection.go index 266b244b713..77f27982c9a 100644 --- a/common/persistence/client/fault_injection.go +++ b/common/persistence/client/fault_injection.go @@ -1034,6 +1034,20 @@ func (t *FaultInjectionTaskStore) CompleteTasksLessThan( return t.baseTaskStore.CompleteTasksLessThan(ctx, request) } +func (t *FaultInjectionTaskStore) GetTaskQueueUserData(ctx context.Context, request *persistence.GetTaskQueueUserDataRequest) (*persistence.InternalGetTaskQueueUserDataResponse, error) { + if err := t.ErrorGenerator.Generate(); err != nil { + return nil, err + } + return t.baseTaskStore.GetTaskQueueUserData(ctx, request) +} + +func (t *FaultInjectionTaskStore) UpdateTaskQueueUserData(ctx context.Context, request *persistence.InternalUpdateTaskQueueUserDataRequest) error { + if err := t.ErrorGenerator.Generate(); err != nil { + return err + } + return t.baseTaskStore.UpdateTaskQueueUserData(ctx, request) +} + func (t *FaultInjectionTaskStore) UpdateRate(rate float64) { t.ErrorGenerator.UpdateRate(rate) } diff --git a/common/persistence/dataInterfaces.go b/common/persistence/dataInterfaces.go index 5723513e6f4..79756073e38 100644 --- a/common/persistence/dataInterfaces.go +++ b/common/persistence/dataInterfaces.go @@ -541,6 +541,24 @@ type ( TaskQueueInfo *persistencespb.TaskQueueInfo } + // GetTaskQueueUserDataRequest is the input type for the GetTaskQueueUserData API + GetTaskQueueUserDataRequest struct { + NamespaceID string + TaskQueue string + } + + // GetTaskQueueUserDataResponse is the output type for the GetTaskQueueUserData API + GetTaskQueueUserDataResponse struct { + UserData *persistencespb.VersionedTaskQueueUserData + } + + // UpdateTaskQueueUserDataRequest is the input type for the UpdateTaskQueueUserData API + UpdateTaskQueueUserDataRequest struct { + NamespaceID string + TaskQueue string + UserData *persistencespb.VersionedTaskQueueUserData + } + // ListTaskQueueRequest contains the request params needed to invoke ListTaskQueue API ListTaskQueueRequest struct { PageSize int @@ -1116,6 +1134,16 @@ type ( // - UnknownNumRowsAffected (this means all rows below value are deleted) // - number of rows deleted, which may be equal to limit CompleteTasksLessThan(ctx context.Context, request *CompleteTasksLessThanRequest) (int, error) + + // GetTaskQueueUserData gets versioned user data. + // This data would only exist if a user uses APIs that generate it, such as the worker versioning related APIs. + // The caller should be prepared to gracefully handle the "NotFound" service error. + GetTaskQueueUserData(ctx context.Context, request *GetTaskQueueUserDataRequest) (*GetTaskQueueUserDataResponse, error) + // UpdateTaskQueueUserData updates the user data for a given task queue. + // The request takes the _current_ known version along with the data to update. + // The caller should +1 increment the cached version number if this call succeeds. + // Fails with ConditionFailedError if the user data was updated concurrently. + UpdateTaskQueueUserData(ctx context.Context, request *UpdateTaskQueueUserDataRequest) error } // MetadataManager is used to manage metadata CRUD for namespace entities diff --git a/common/persistence/dataInterfaces_mock.go b/common/persistence/dataInterfaces_mock.go index b2e7ed5e260..1e85821f95f 100644 --- a/common/persistence/dataInterfaces_mock.go +++ b/common/persistence/dataInterfaces_mock.go @@ -811,6 +811,21 @@ func (mr *MockTaskManagerMockRecorder) GetTaskQueue(ctx, request interface{}) *g return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTaskQueue", reflect.TypeOf((*MockTaskManager)(nil).GetTaskQueue), ctx, request) } +// GetTaskQueueUserData mocks base method. +func (m *MockTaskManager) GetTaskQueueUserData(ctx context.Context, request *GetTaskQueueUserDataRequest) (*GetTaskQueueUserDataResponse, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetTaskQueueUserData", ctx, request) + ret0, _ := ret[0].(*GetTaskQueueUserDataResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetTaskQueueUserData indicates an expected call of GetTaskQueueUserData. +func (mr *MockTaskManagerMockRecorder) GetTaskQueueUserData(ctx, request interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTaskQueueUserData", reflect.TypeOf((*MockTaskManager)(nil).GetTaskQueueUserData), ctx, request) +} + // GetTasks mocks base method. func (m *MockTaskManager) GetTasks(ctx context.Context, request *GetTasksRequest) (*GetTasksResponse, error) { m.ctrl.T.Helper() @@ -856,6 +871,20 @@ func (mr *MockTaskManagerMockRecorder) UpdateTaskQueue(ctx, request interface{}) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateTaskQueue", reflect.TypeOf((*MockTaskManager)(nil).UpdateTaskQueue), ctx, request) } +// UpdateTaskQueueUserData mocks base method. +func (m *MockTaskManager) UpdateTaskQueueUserData(ctx context.Context, request *UpdateTaskQueueUserDataRequest) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdateTaskQueueUserData", ctx, request) + ret0, _ := ret[0].(error) + return ret0 +} + +// UpdateTaskQueueUserData indicates an expected call of UpdateTaskQueueUserData. +func (mr *MockTaskManagerMockRecorder) UpdateTaskQueueUserData(ctx, request interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateTaskQueueUserData", reflect.TypeOf((*MockTaskManager)(nil).UpdateTaskQueueUserData), ctx, request) +} + // MockMetadataManager is a mock of MetadataManager interface. type MockMetadataManager struct { ctrl *gomock.Controller diff --git a/common/persistence/mock/store_mock.go b/common/persistence/mock/store_mock.go index e2601f32260..d0601f5e79d 100644 --- a/common/persistence/mock/store_mock.go +++ b/common/persistence/mock/store_mock.go @@ -279,6 +279,21 @@ func (mr *MockTaskStoreMockRecorder) GetTaskQueue(ctx, request interface{}) *gom return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTaskQueue", reflect.TypeOf((*MockTaskStore)(nil).GetTaskQueue), ctx, request) } +// GetTaskQueueUserData mocks base method. +func (m *MockTaskStore) GetTaskQueueUserData(ctx context.Context, request *persistence.GetTaskQueueUserDataRequest) (*persistence.InternalGetTaskQueueUserDataResponse, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetTaskQueueUserData", ctx, request) + ret0, _ := ret[0].(*persistence.InternalGetTaskQueueUserDataResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetTaskQueueUserData indicates an expected call of GetTaskQueueUserData. +func (mr *MockTaskStoreMockRecorder) GetTaskQueueUserData(ctx, request interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTaskQueueUserData", reflect.TypeOf((*MockTaskStore)(nil).GetTaskQueueUserData), ctx, request) +} + // GetTasks mocks base method. func (m *MockTaskStore) GetTasks(ctx context.Context, request *persistence.GetTasksRequest) (*persistence.InternalGetTasksResponse, error) { m.ctrl.T.Helper() @@ -324,6 +339,20 @@ func (mr *MockTaskStoreMockRecorder) UpdateTaskQueue(ctx, request interface{}) * return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateTaskQueue", reflect.TypeOf((*MockTaskStore)(nil).UpdateTaskQueue), ctx, request) } +// UpdateTaskQueueUserData mocks base method. +func (m *MockTaskStore) UpdateTaskQueueUserData(ctx context.Context, request *persistence.InternalUpdateTaskQueueUserDataRequest) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdateTaskQueueUserData", ctx, request) + ret0, _ := ret[0].(error) + return ret0 +} + +// UpdateTaskQueueUserData indicates an expected call of UpdateTaskQueueUserData. +func (mr *MockTaskStoreMockRecorder) UpdateTaskQueueUserData(ctx, request interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateTaskQueueUserData", reflect.TypeOf((*MockTaskStore)(nil).UpdateTaskQueueUserData), ctx, request) +} + // MockMetadataStore is a mock of MetadataStore interface. type MockMetadataStore struct { ctrl *gomock.Controller diff --git a/common/persistence/persistenceInterface.go b/common/persistence/persistenceInterface.go index d9f10259e7a..1bcede76ea6 100644 --- a/common/persistence/persistenceInterface.go +++ b/common/persistence/persistenceInterface.go @@ -72,6 +72,8 @@ type ( GetTasks(ctx context.Context, request *GetTasksRequest) (*InternalGetTasksResponse, error) CompleteTask(ctx context.Context, request *CompleteTaskRequest) error CompleteTasksLessThan(ctx context.Context, request *CompleteTasksLessThanRequest) (int, error) + GetTaskQueueUserData(ctx context.Context, request *GetTaskQueueUserDataRequest) (*InternalGetTaskQueueUserDataResponse, error) + UpdateTaskQueueUserData(ctx context.Context, request *InternalUpdateTaskQueueUserDataRequest) error } // MetadataStore is a lower level of MetadataManager MetadataStore interface { @@ -238,6 +240,11 @@ type ( TaskQueueInfo *commonpb.DataBlob } + InternalGetTaskQueueUserDataResponse struct { + Version int64 + UserData *commonpb.DataBlob + } + InternalUpdateTaskQueueRequest struct { NamespaceID string TaskQueue string @@ -251,6 +258,13 @@ type ( PrevRangeID int64 } + InternalUpdateTaskQueueUserDataRequest struct { + NamespaceID string + TaskQueue string + Version int64 + UserData *commonpb.DataBlob + } + InternalCreateTasksRequest struct { NamespaceID string TaskQueue string diff --git a/common/persistence/persistenceMetricClients.go b/common/persistence/persistenceMetricClients.go index ee5a502184b..602657c95a9 100644 --- a/common/persistence/persistenceMetricClients.go +++ b/common/persistence/persistenceMetricClients.go @@ -596,6 +596,30 @@ func (p *taskPersistenceClient) DeleteTaskQueue( return p.persistence.DeleteTaskQueue(ctx, request) } +func (p *taskPersistenceClient) GetTaskQueueUserData( + ctx context.Context, + request *GetTaskQueueUserDataRequest, +) (_ *GetTaskQueueUserDataResponse, retErr error) { + caller := headers.GetCallerInfo(ctx).CallerName + startTime := time.Now().UTC() + defer func() { + p.recordRequestMetrics(metrics.PersistenceGetTaskQueueUserDataScope, caller, startTime, retErr) + }() + return p.persistence.GetTaskQueueUserData(ctx, request) +} + +func (p *taskPersistenceClient) UpdateTaskQueueUserData( + ctx context.Context, + request *UpdateTaskQueueUserDataRequest, +) (retErr error) { + caller := headers.GetCallerInfo(ctx).CallerName + startTime := time.Now().UTC() + defer func() { + p.recordRequestMetrics(metrics.PersistenceUpdateTaskQueueUserDataScope, caller, startTime, retErr) + }() + return p.persistence.UpdateTaskQueueUserData(ctx, request) +} + func (p *taskPersistenceClient) Close() { p.persistence.Close() } diff --git a/common/persistence/persistenceRateLimitedClients.go b/common/persistence/persistenceRateLimitedClients.go index e3f73437adc..dc1a649a05b 100644 --- a/common/persistence/persistenceRateLimitedClients.go +++ b/common/persistence/persistenceRateLimitedClients.go @@ -538,6 +538,26 @@ func (p *taskRateLimitedPersistenceClient) DeleteTaskQueue( return p.persistence.DeleteTaskQueue(ctx, request) } +func (p taskRateLimitedPersistenceClient) GetTaskQueueUserData( + ctx context.Context, + request *GetTaskQueueUserDataRequest, +) (*GetTaskQueueUserDataResponse, error) { + if ok := allow(ctx, "GetTaskQueueUserData", p.rateLimiter); !ok { + return nil, ErrPersistenceLimitExceeded + } + return p.persistence.GetTaskQueueUserData(ctx, request) +} + +func (p taskRateLimitedPersistenceClient) UpdateTaskQueueUserData( + ctx context.Context, + request *UpdateTaskQueueUserDataRequest, +) error { + if ok := allow(ctx, "UpdateTaskQueueUserData", p.rateLimiter); !ok { + return ErrPersistenceLimitExceeded + } + return p.persistence.UpdateTaskQueueUserData(ctx, request) +} + func (p *taskRateLimitedPersistenceClient) Close() { p.persistence.Close() } diff --git a/common/persistence/persistenceRetryableClients.go b/common/persistence/persistenceRetryableClients.go index 67ef0f0d3cd..536306b5be1 100644 --- a/common/persistence/persistenceRetryableClients.go +++ b/common/persistence/persistenceRetryableClients.go @@ -760,6 +760,33 @@ func (p *taskRetryablePersistenceClient) DeleteTaskQueue( return backoff.ThrottleRetryContext(ctx, op, p.policy, p.isRetryable) } +func (p *taskRetryablePersistenceClient) GetTaskQueueUserData( + ctx context.Context, + request *GetTaskQueueUserDataRequest, +) (*GetTaskQueueUserDataResponse, error) { + var response *GetTaskQueueUserDataResponse + op := func(ctx context.Context) error { + var err error + response, err = p.persistence.GetTaskQueueUserData(ctx, request) + return err + } + + err := backoff.ThrottleRetryContext(ctx, op, p.policy, p.isRetryable) + return response, err +} + +func (p *taskRetryablePersistenceClient) UpdateTaskQueueUserData( + ctx context.Context, + request *UpdateTaskQueueUserDataRequest, +) error { + op := func(ctx context.Context) error { + return p.persistence.UpdateTaskQueueUserData(ctx, request) + } + + err := backoff.ThrottleRetryContext(ctx, op, p.policy, p.isRetryable) + return err +} + func (p *taskRetryablePersistenceClient) Close() { p.persistence.Close() } diff --git a/common/persistence/serialization/serializer.go b/common/persistence/serialization/serializer.go index 2dc7f803534..9073e166606 100644 --- a/common/persistence/serialization/serializer.go +++ b/common/persistence/serialization/serializer.go @@ -94,6 +94,9 @@ type ( TaskQueueInfoToBlob(info *persistencespb.TaskQueueInfo, encodingType enumspb.EncodingType) (*commonpb.DataBlob, error) TaskQueueInfoFromBlob(data *commonpb.DataBlob) (*persistencespb.TaskQueueInfo, error) + TaskQueueUserDataToBlob(info *persistencespb.TaskQueueUserData, encodingType enumspb.EncodingType) (*commonpb.DataBlob, error) + TaskQueueUserDataFromBlob(data *commonpb.DataBlob) (*persistencespb.TaskQueueUserData, error) + ChecksumToBlob(checksum *persistencespb.Checksum, encodingType enumspb.EncodingType) (*commonpb.DataBlob, error) ChecksumFromBlob(data *commonpb.DataBlob) (*persistencespb.Checksum, error) @@ -473,6 +476,15 @@ func (t *serializerImpl) TaskQueueInfoFromBlob(data *commonpb.DataBlob) (*persis return result, ProtoDecodeBlob(data, result) } +func (t *serializerImpl) TaskQueueUserDataToBlob(data *persistencespb.TaskQueueUserData, encodingType enumspb.EncodingType) (*commonpb.DataBlob, error) { + return ProtoEncodeBlob(data, encodingType) +} + +func (t *serializerImpl) TaskQueueUserDataFromBlob(data *commonpb.DataBlob) (*persistencespb.TaskQueueUserData, error) { + result := &persistencespb.TaskQueueUserData{} + return result, ProtoDecodeBlob(data, result) +} + func (t *serializerImpl) ChecksumToBlob(checksum *persistencespb.Checksum, encodingType enumspb.EncodingType) (*commonpb.DataBlob, error) { // nil is replaced with empty object because it is not supported for "checksum" field in DB. if checksum == nil { diff --git a/common/persistence/sql/sqlplugin/matching_task_queue.go b/common/persistence/sql/sqlplugin/matching_task_queue.go index ac00fc98336..8e7bf74b05e 100644 --- a/common/persistence/sql/sqlplugin/matching_task_queue.go +++ b/common/persistence/sql/sqlplugin/matching_task_queue.go @@ -51,6 +51,25 @@ type ( PageSize *int } + GetTaskQueueUserDataRequest struct { + NamespaceID []byte + TaskQueueName string + } + + UpdateTaskQueueDataRequest struct { + NamespaceID []byte + TaskQueueName string + Version int64 + Data []byte + DataEncoding string + } + + VersionedBlob struct { + Version int64 + Data []byte + DataEncoding string + } + // MatchingTaskQueue is the SQL persistence interface for matching task queues MatchingTaskQueue interface { InsertIntoTaskQueues(ctx context.Context, row *TaskQueuesRow) (sql.Result, error) @@ -62,5 +81,7 @@ type ( SelectFromTaskQueues(ctx context.Context, filter TaskQueuesFilter) ([]TaskQueuesRow, error) DeleteFromTaskQueues(ctx context.Context, filter TaskQueuesFilter) (sql.Result, error) LockTaskQueues(ctx context.Context, filter TaskQueuesFilter) (int64, error) + GetTaskQueueUserData(ctx context.Context, request *GetTaskQueueUserDataRequest) (*VersionedBlob, error) + UpdateTaskQueueUserData(ctx context.Context, request *UpdateTaskQueueDataRequest) error } ) diff --git a/common/persistence/sql/sqlplugin/mysql/task.go b/common/persistence/sql/sqlplugin/mysql/task.go index 49ba4e8489d..a0597ab3a77 100644 --- a/common/persistence/sql/sqlplugin/mysql/task.go +++ b/common/persistence/sql/sqlplugin/mysql/task.go @@ -31,6 +31,7 @@ import ( "go.temporal.io/api/serviceerror" + "go.temporal.io/server/common/persistence" "go.temporal.io/server/common/persistence/sql/sqlplugin" ) @@ -87,6 +88,21 @@ task_queue_id = :task_queue_id rangeDeleteTaskQry = `DELETE FROM tasks ` + `WHERE range_hash = ? AND task_queue_id = ? AND task_id < ? ` + `ORDER BY task_queue_id,task_id LIMIT ?` + + getTaskQueueUserDataQry = `SELECT data, data_encoding, version FROM task_queue_user_data ` + + `WHERE namespace_id = ? AND task_queue_name = ?` + + updateTaskQueueUserDataQry = `UPDATE task_queue_user_data SET ` + + `data = ?, ` + + `data_encoding = ?, ` + + `version = ? ` + + `WHERE namespace_id = ? ` + + `AND task_queue_name = ? ` + + `AND version = ?` + + insertTaskQueueUserDataQry = `INSERT INTO task_queue_user_data` + + `(namespace_id, task_queue_name, data, data_encoding, version) ` + + `VALUES (?, ?, ?, ?, 1)` ) // InsertIntoTasks inserts one or more rows into tasks table @@ -278,3 +294,42 @@ func (mdb *db) LockTaskQueues( ) return rangeID, err } + +func (mdb *db) GetTaskQueueUserData(ctx context.Context, request *sqlplugin.GetTaskQueueUserDataRequest) (*sqlplugin.VersionedBlob, error) { + var row sqlplugin.VersionedBlob + err := mdb.conn.GetContext(ctx, &row, getTaskQueueUserDataQry, request.NamespaceID, request.TaskQueueName) + return &row, err +} + +func (mdb *db) UpdateTaskQueueUserData(ctx context.Context, request *sqlplugin.UpdateTaskQueueDataRequest) error { + if request.Version == 0 { + _, err := mdb.conn.ExecContext( + ctx, + insertTaskQueueUserDataQry, + request.NamespaceID, + request.TaskQueueName, + request.Data, + request.DataEncoding) + return err + } + result, err := mdb.conn.ExecContext( + ctx, + updateTaskQueueUserDataQry, + request.Data, + request.DataEncoding, + request.Version+1, + request.NamespaceID, + request.TaskQueueName, + request.Version) + if err != nil { + return err + } + numRows, err := result.RowsAffected() + if err != nil { + return err + } + if numRows != 1 { + return &persistence.ConditionFailedError{Msg: "Expected exactly one row to be updated"} + } + return nil +} diff --git a/common/persistence/sql/sqlplugin/postgresql/task.go b/common/persistence/sql/sqlplugin/postgresql/task.go index 3fb11d43d97..b2bda779132 100644 --- a/common/persistence/sql/sqlplugin/postgresql/task.go +++ b/common/persistence/sql/sqlplugin/postgresql/task.go @@ -31,6 +31,7 @@ import ( "go.temporal.io/api/serviceerror" + "go.temporal.io/server/common/persistence" "go.temporal.io/server/common/persistence/sql/sqlplugin" ) @@ -88,6 +89,21 @@ task_queue_id = :task_queue_id `WHERE range_hash = $1 AND task_queue_id = $2 AND task_id IN (SELECT task_id FROM tasks WHERE range_hash = $1 AND task_queue_id = $2 AND task_id < $3 ` + `ORDER BY task_queue_id,task_id LIMIT $4 )` + + getTaskQueueUserDataQry = `SELECT data, data_encoding, version FROM task_queue_user_data ` + + `WHERE namespace_id = $1 AND task_queue_name = $2` + + updateTaskQueueUserDataQry = `UPDATE task_queue_user_data SET ` + + `data = $1, ` + + `data_encoding = $2, ` + + `version = $3 ` + + `WHERE namespace_id = $4 ` + + `AND task_queue_name = $5 ` + + `AND version = $6` + + insertTaskQueueUserDataQry = `INSERT INTO task_queue_user_data` + + `(namespace_id, task_queue_name, data, data_encoding, version) ` + + `VALUES ($1, $2, $3, $4, 1)` ) // InsertIntoTasks inserts one or more rows into tasks table @@ -278,3 +294,42 @@ func (pdb *db) LockTaskQueues( ) return rangeID, err } + +func (pdb *db) GetTaskQueueUserData(ctx context.Context, request *sqlplugin.GetTaskQueueUserDataRequest) (*sqlplugin.VersionedBlob, error) { + var row sqlplugin.VersionedBlob + err := pdb.conn.GetContext(ctx, &row, getTaskQueueUserDataQry, request.NamespaceID, request.TaskQueueName) + return &row, err +} + +func (pdb *db) UpdateTaskQueueUserData(ctx context.Context, request *sqlplugin.UpdateTaskQueueDataRequest) error { + if request.Version == 0 { + _, err := pdb.conn.ExecContext( + ctx, + insertTaskQueueUserDataQry, + request.NamespaceID, + request.TaskQueueName, + request.Data, + request.DataEncoding) + return err + } + result, err := pdb.conn.ExecContext( + ctx, + updateTaskQueueUserDataQry, + request.Data, + request.DataEncoding, + request.Version+1, + request.NamespaceID, + request.TaskQueueName, + request.Version) + if err != nil { + return err + } + numRows, err := result.RowsAffected() + if err != nil { + return err + } + if numRows != 1 { + return &persistence.ConditionFailedError{Msg: "Expected exactly one row to be updated"} + } + return nil +} diff --git a/common/persistence/sql/sqlplugin/sqlite/task.go b/common/persistence/sql/sqlplugin/sqlite/task.go index c7420016c24..f098e40d18c 100644 --- a/common/persistence/sql/sqlplugin/sqlite/task.go +++ b/common/persistence/sql/sqlplugin/sqlite/task.go @@ -33,6 +33,7 @@ import ( "go.temporal.io/api/serviceerror" + "go.temporal.io/server/common/persistence" "go.temporal.io/server/common/persistence/sql/sqlplugin" ) @@ -90,6 +91,21 @@ task_queue_id = :task_queue_id `WHERE range_hash = ? AND task_queue_id = ? AND task_id IN (SELECT task_id FROM tasks WHERE range_hash = ? AND task_queue_id = ? AND task_id < ? ` + `ORDER BY task_queue_id,task_id LIMIT ? ) ` + + getTaskQueueUserDataQry = `SELECT data, data_encoding, version FROM task_queue_user_data ` + + `WHERE namespace_id = ? AND task_queue_name = ?` + + updateTaskQueueUserDataQry = `UPDATE task_queue_user_data SET ` + + `data = ?, ` + + `data_encoding = ?, ` + + `version = ? ` + + `WHERE namespace_id = ? ` + + `AND task_queue_name = ? ` + + `AND version = ?` + + insertTaskQueueUserDataQry = `INSERT INTO task_queue_user_data` + + `(namespace_id, task_queue_name, data, data_encoding, version) ` + + `VALUES (?, ?, ?, ?, 1)` ) // InsertIntoTasks inserts one or more rows into tasks table @@ -283,3 +299,42 @@ func (mdb *db) LockTaskQueues( ) return rangeID, err } + +func (mdb *db) GetTaskQueueUserData(ctx context.Context, request *sqlplugin.GetTaskQueueUserDataRequest) (*sqlplugin.VersionedBlob, error) { + var row sqlplugin.VersionedBlob + err := mdb.conn.GetContext(ctx, &row, getTaskQueueUserDataQry, request.NamespaceID, request.TaskQueueName) + return &row, err +} + +func (mdb *db) UpdateTaskQueueUserData(ctx context.Context, request *sqlplugin.UpdateTaskQueueDataRequest) error { + if request.Version == 0 { + _, err := mdb.conn.ExecContext( + ctx, + insertTaskQueueUserDataQry, + request.NamespaceID, + request.TaskQueueName, + request.Data, + request.DataEncoding) + return err + } + result, err := mdb.conn.ExecContext( + ctx, + updateTaskQueueUserDataQry, + request.Data, + request.DataEncoding, + request.Version+1, + request.NamespaceID, + request.TaskQueueName, + request.Version) + if err != nil { + return err + } + numRows, err := result.RowsAffected() + if err != nil { + return err + } + if numRows != 1 { + return &persistence.ConditionFailedError{Msg: "Expected exactly one row to be updated"} + } + return nil +} diff --git a/common/persistence/sql/task.go b/common/persistence/sql/task.go index fd2d0b758a7..b04b25e2427 100644 --- a/common/persistence/sql/task.go +++ b/common/persistence/sql/task.go @@ -477,6 +477,45 @@ func (m *sqlTaskManager) CompleteTasksLessThan( return int(nRows), nil } +func (m *sqlTaskManager) GetTaskQueueUserData(ctx context.Context, request *persistence.GetTaskQueueUserDataRequest) (*persistence.InternalGetTaskQueueUserDataResponse, error) { + namespaceID, err := primitives.ParseUUID(request.NamespaceID) + if err != nil { + return nil, serviceerror.NewInternal(fmt.Sprintf("failed to parse namespace ID as UUID: %v", err)) + } + response, err := m.Db.GetTaskQueueUserData(ctx, &sqlplugin.GetTaskQueueUserDataRequest{ + NamespaceID: namespaceID, + TaskQueueName: request.TaskQueue, + }) + if err != nil { + if err == sql.ErrNoRows { + return nil, serviceerror.NewNotFound(fmt.Sprintf("task queue user data not found for %v.%v", request.NamespaceID, request.TaskQueue)) + } + return nil, err + } + return &persistence.InternalGetTaskQueueUserDataResponse{ + Version: response.Version, + UserData: persistence.NewDataBlob(response.Data, response.DataEncoding), + }, nil +} + +func (m *sqlTaskManager) UpdateTaskQueueUserData(ctx context.Context, request *persistence.InternalUpdateTaskQueueUserDataRequest) error { + namespaceID, err := primitives.ParseUUID(request.NamespaceID) + if err != nil { + return serviceerror.NewInternal(fmt.Sprintf("failed to parse namespace ID as UUID: %v", err)) + } + err = m.Db.UpdateTaskQueueUserData(ctx, &sqlplugin.UpdateTaskQueueDataRequest{ + NamespaceID: namespaceID, + TaskQueueName: request.TaskQueue, + Data: request.UserData.Data, + DataEncoding: request.UserData.EncodingType.String(), + Version: request.Version, + }) + if m.Db.IsDupEntryError(err) { + return &persistence.ConditionFailedError{Msg: err.Error()} + } + return err +} + // Returns uint32 hash for a particular TaskQueue/Task given a Namespace, TaskQueueName and TaskQueueType func (m *sqlTaskManager) taskQueueIdAndHash( namespaceID primitives.UUID, diff --git a/common/persistence/task_manager.go b/common/persistence/task_manager.go index 18d0102533a..506bdcab08e 100644 --- a/common/persistence/task_manager.go +++ b/common/persistence/task_manager.go @@ -248,3 +248,31 @@ func (m *taskManagerImpl) CompleteTasksLessThan( ) (int, error) { return m.taskStore.CompleteTasksLessThan(ctx, request) } + +// GetTaskQueueUserData implements TaskManager +func (m *taskManagerImpl) GetTaskQueueUserData(ctx context.Context, request *GetTaskQueueUserDataRequest) (*GetTaskQueueUserDataResponse, error) { + response, err := m.taskStore.GetTaskQueueUserData(ctx, request) + if err != nil { + return nil, err + } + data, err := m.serializer.TaskQueueUserDataFromBlob(response.UserData) + if err != nil { + return nil, err + } + return &GetTaskQueueUserDataResponse{UserData: &persistencespb.VersionedTaskQueueUserData{Version: response.Version, Data: data}}, nil +} + +// UpdateTaskQueueUserData implements TaskManager +func (m *taskManagerImpl) UpdateTaskQueueUserData(ctx context.Context, request *UpdateTaskQueueUserDataRequest) error { + userData, err := m.serializer.TaskQueueUserDataToBlob(request.UserData.Data, enumspb.ENCODING_TYPE_PROTO3) + if err != nil { + return err + } + internalRequest := &InternalUpdateTaskQueueUserDataRequest{ + NamespaceID: request.NamespaceID, + TaskQueue: request.TaskQueue, + Version: request.UserData.Version, + UserData: userData, + } + return m.taskStore.UpdateTaskQueueUserData(ctx, internalRequest) +} diff --git a/go.sum b/go.sum index 8ec45f92e25..b5c06b11214 100644 --- a/go.sum +++ b/go.sum @@ -1116,10 +1116,8 @@ go.opentelemetry.io/proto/otlp v0.7.0/go.mod h1:PqfVotwruBrMGOCsRd/89rSnXhoiJIqe go.opentelemetry.io/proto/otlp v0.15.0/go.mod h1:H7XAot3MsfNsj7EXtrA2q5xSNQ10UqI405h3+duxN4U= go.opentelemetry.io/proto/otlp v0.19.0 h1:IVN6GR+mhC4s5yfcTbmzHYODqvWAp3ZedA2SJPI1Nnw= go.opentelemetry.io/proto/otlp v0.19.0/go.mod h1:H7XAot3MsfNsj7EXtrA2q5xSNQ10UqI405h3+duxN4U= -go.temporal.io/api v1.19.1-0.20230322213042-07fb271d475b/go.mod h1:PLQJqp1YZZikmtGm9jIbzWpP3p6zS39WQjhsO/Hiw30= go.temporal.io/api v1.19.1-0.20230414223259-557a75eaec60 h1:/kgPfmn9+EIwB81319jtEFtuCGHneiM5hBk3pXwFeVk= go.temporal.io/api v1.19.1-0.20230414223259-557a75eaec60/go.mod h1:OiRzMU/dM++aM7IexDcAk0yLc1Pktdr/MUMD0gdpXy8= -go.temporal.io/sdk v1.22.1/go.mod h1:LqYtPesETgMHktpH98Vk7WegNcikxErmmuaZPNWEnPw= go.temporal.io/sdk v1.22.2-0.20230414224335-da95b25113ee h1:UNY44uAclRarh42b9LANzTSsp219buaF1HU3UVPEjFw= go.temporal.io/sdk v1.22.2-0.20230414224335-da95b25113ee/go.mod h1:LEB3P5uOvrzpUIgYU27LPBVdxdCHFSsh3gY5kP3k/iY= go.temporal.io/version v0.3.0 h1:dMrei9l9NyHt8nG6EB8vAwDLLTwx2SvRyucCSumAiig= @@ -1720,7 +1718,6 @@ google.golang.org/genproto v0.0.0-20230223222841-637eb2293923/go.mod h1:3Dl5ZL0q google.golang.org/genproto v0.0.0-20230303212802-e74f57abe488/go.mod h1:TvhZT5f700eVlTNwND1xoEZQeWTB2RY/65kplwl/bFA= google.golang.org/genproto v0.0.0-20230306155012-7f2fa6fef1f4/go.mod h1:NWraEVixdDnqcqQ30jipen1STv2r/n24Wb7twVTGR4s= google.golang.org/genproto v0.0.0-20230320184635-7606e756e683/go.mod h1:NWraEVixdDnqcqQ30jipen1STv2r/n24Wb7twVTGR4s= -google.golang.org/genproto v0.0.0-20230322174352-cde4c949918d/go.mod h1:NWraEVixdDnqcqQ30jipen1STv2r/n24Wb7twVTGR4s= google.golang.org/genproto v0.0.0-20230323212658-478b75c54725/go.mod h1:UUQDJDOlWu4KYeJZffbWgBkS1YFobzKbLVfK69pe0Ak= google.golang.org/genproto v0.0.0-20230330154414-c0448cd141ea/go.mod h1:UUQDJDOlWu4KYeJZffbWgBkS1YFobzKbLVfK69pe0Ak= google.golang.org/genproto v0.0.0-20230331144136-dcfb400f0633/go.mod h1:UUQDJDOlWu4KYeJZffbWgBkS1YFobzKbLVfK69pe0Ak= diff --git a/proto/internal/temporal/server/api/matchingservice/v1/request_response.proto b/proto/internal/temporal/server/api/matchingservice/v1/request_response.proto index d3810faf3ef..83037bf9584 100644 --- a/proto/internal/temporal/server/api/matchingservice/v1/request_response.proto +++ b/proto/internal/temporal/server/api/matchingservice/v1/request_response.proto @@ -37,7 +37,7 @@ import "temporal/api/protocol/v1/message.proto"; import "temporal/server/api/clock/v1/message.proto"; import "temporal/server/api/enums/v1/task.proto"; import "temporal/server/api/history/v1/message.proto"; -import "temporal/server/api/persistence/v1/tasks.proto"; +import "temporal/server/api/persistence/v1/task_queues.proto"; import "temporal/api/workflowservice/v1/request_response.proto"; @@ -203,32 +203,29 @@ message GetWorkerBuildIdCompatibilityResponse { temporal.api.workflowservice.v1.GetWorkerBuildIdCompatibilityResponse response = 1; } -message InvalidateTaskQueueMetadataRequest { +message InvalidateTaskQueueUserDataRequest { string namespace_id = 1; string task_queue = 2; temporal.api.enums.v1.TaskQueueType task_queue_type = 3; - // The task queue versioning data should be invalidated and replaced with this data, if set. - temporal.server.api.persistence.v1.VersioningData versioning_data = 4; + // The partition's cached user data should be invalidated and replaced with this data, if set. + temporal.server.api.persistence.v1.VersionedTaskQueueUserData user_data = 4; } -message InvalidateTaskQueueMetadataResponse {} +message InvalidateTaskQueueUserDataResponse {} -message GetTaskQueueMetadataRequest { +message GetTaskQueueUserDataRequest { string namespace_id = 1; // The task queue to fetch data from. Is always considered as a workflow queue, since root // workflow queues own the metadata. string task_queue = 2; - // If set nonempty, the requester wants the latest versioning data. The value must be the hash - // (using farm hash Fingerprint64) of the latest versioning data. If the requester has no data, - // it can use any invalid value (ex: [0]). - // If the data is up to date, no value will be returned. - bytes want_versioning_data_curhash = 3; -} -message GetTaskQueueMetadataResponse { - oneof versioning_data_resp { - // The latest versioning data, if the request's hash did not match. May be null if no - // versioning data exists. - temporal.server.api.persistence.v1.VersioningData versioning_data = 1; - // If the request's hash matched, this variant is set (and will be true). - bool matched_req_hash = 2; - } + // The value of the last known user data version. + // If the requester has no data, it should set this to 0. + // This value must not be set to a negative number (note that our linter suggests avoiding uint64). + int64 last_known_user_data_version = 3; +} +message GetTaskQueueUserDataResponse { + // Whether this task queue has any stored user data + bool task_queue_has_user_data = 1; + // Versioned user data, set if the task queue has user data and the request's last_known_user_data_version is less + // than the version cached in the root partition. + temporal.server.api.persistence.v1.VersionedTaskQueueUserData user_data = 2; } diff --git a/proto/internal/temporal/server/api/matchingservice/v1/service.proto b/proto/internal/temporal/server/api/matchingservice/v1/service.proto index 5e4a337507b..84b3be87679 100644 --- a/proto/internal/temporal/server/api/matchingservice/v1/service.proto +++ b/proto/internal/temporal/server/api/matchingservice/v1/service.proto @@ -85,8 +85,8 @@ service MatchingService { // aip.dev/not-precedent: UpdateWorkerBuildIdOrdering RPC doesn't follow Google API format. --) rpc UpdateWorkerBuildIdCompatibility (UpdateWorkerBuildIdCompatibilityRequest) returns (UpdateWorkerBuildIdCompatibilityResponse) {} rpc GetWorkerBuildIdCompatibility (GetWorkerBuildIdCompatibilityRequest) returns (GetWorkerBuildIdCompatibilityResponse) {} - // Tell a task queue that some metadata has changed. - rpc InvalidateTaskQueueMetadata (InvalidateTaskQueueMetadataRequest) returns (InvalidateTaskQueueMetadataResponse) {} - // Fetch some metadata about a task queue. - rpc GetTaskQueueMetadata (GetTaskQueueMetadataRequest) returns (GetTaskQueueMetadataResponse) {} + // Tell a task queue that the associated user data has changed. + rpc InvalidateTaskQueueUserData (InvalidateTaskQueueUserDataRequest) returns (InvalidateTaskQueueUserDataResponse) {} + // Fetch user data for a task queue, this request should always be routed to the node holding the task queue's root partition. + rpc GetTaskQueueUserData (GetTaskQueueUserDataRequest) returns (GetTaskQueueUserDataResponse) {} } diff --git a/proto/internal/temporal/server/api/persistence/v1/task_queues.proto b/proto/internal/temporal/server/api/persistence/v1/task_queues.proto index 4e75d20191a..6d023a63481 100644 --- a/proto/internal/temporal/server/api/persistence/v1/task_queues.proto +++ b/proto/internal/temporal/server/api/persistence/v1/task_queues.proto @@ -84,3 +84,9 @@ message TaskQueueUserData { // For future use: description, rate limits, manual partition control, etc... } + +// Simple wrapper that includes a TaskQueueUserData and its storage version. +message VersionedTaskQueueUserData { + TaskQueueUserData data = 1; + int64 version = 2; +} diff --git a/schema/cassandra/temporal/versioned/v1.21/manifest.json b/schema/cassandra/temporal/versioned/v1.21/manifest.json new file mode 100644 index 00000000000..8f292ee8f6b --- /dev/null +++ b/schema/cassandra/temporal/versioned/v1.21/manifest.json @@ -0,0 +1,6 @@ +{ + "CurrVersion": "1.21", + "MinCompatibleVersion": "1.0", + "Description": "create task_queue_user_data table", + "SchemaUpdateCqlFiles": ["task_queue_user_data.cql"] +} diff --git a/schema/cassandra/temporal/versioned/v1.21/task_queue_user_data.cql b/schema/cassandra/temporal/versioned/v1.21/task_queue_user_data.cql new file mode 100644 index 00000000000..a2a8f032cdc --- /dev/null +++ b/schema/cassandra/temporal/versioned/v1.21/task_queue_user_data.cql @@ -0,0 +1,15 @@ +-- Stores task queue information such as user provided versioning data +CREATE TABLE task_queue_user_data ( + namespace_id uuid, + task_queue_name text, + data blob, -- temporal.server.api.persistence.v1.TaskQueueUserData + data_encoding text, -- Encoding type used for serialization, in practice this should always be proto3 + version bigint, -- Version of this row, used for optimistic concurrency + -- task_queue_name is not a part of the parititioning key to allow cheaply iterating all task queues in a single + -- namespace. Access to this table should be infrequent enough that a single partition per namespace can be used. + -- Note that this imposes a limit on total task queue user data within one namespace (see the relevant single + -- partition Cassandra limits). + PRIMARY KEY ((namespace_id), task_queue_name) +) WITH COMPACTION = { + 'class': 'org.apache.cassandra.db.compaction.LeveledCompactionStrategy' + }; diff --git a/schema/cassandra/version.go b/schema/cassandra/version.go index 554a24da6a6..8e3e58a38b6 100644 --- a/schema/cassandra/version.go +++ b/schema/cassandra/version.go @@ -27,7 +27,7 @@ package cassandra // NOTE: whenever there is a new database schema update, plz update the following versions // Version is the Cassandra database release version -const Version = "1.7" +const Version = "1.21" // VisibilityVersion is the Cassandra visibility database release version const VisibilityVersion = "1.0" diff --git a/schema/mysql/v57/temporal/versioned/v1.21/manifest.json b/schema/mysql/v57/temporal/versioned/v1.21/manifest.json new file mode 100644 index 00000000000..ccc86291369 --- /dev/null +++ b/schema/mysql/v57/temporal/versioned/v1.21/manifest.json @@ -0,0 +1,6 @@ +{ + "CurrVersion": "1.21", + "MinCompatibleVersion": "1.0", + "Description": "create task_queue_user_data table", + "SchemaUpdateCqlFiles": ["task_queue_user_data.sql"] +} diff --git a/schema/mysql/v57/temporal/versioned/v1.21/task_queue_user_data.sql b/schema/mysql/v57/temporal/versioned/v1.21/task_queue_user_data.sql new file mode 100644 index 00000000000..80926e417c8 --- /dev/null +++ b/schema/mysql/v57/temporal/versioned/v1.21/task_queue_user_data.sql @@ -0,0 +1,9 @@ +-- Stores task queue information such as user provided versioning data +CREATE TABLE task_queue_user_data ( + namespace_id BINARY(16) NOT NULL, + task_queue_name VARCHAR(255) NOT NULL, + data MEDIUMBLOB NOT NULL, -- temporal.server.api.persistence.v1.TaskQueueUserData + data_encoding VARCHAR(16) NOT NULL, -- Encoding type used for serialization, in practice this should always be proto3 + version BIGINT NOT NULL, -- Version of this row, used for optimistic concurrency + PRIMARY KEY (namespace_id, task_queue_name) +); diff --git a/schema/mysql/v57/version.go b/schema/mysql/v57/version.go index d4a22d65241..ff5099b72e4 100644 --- a/schema/mysql/v57/version.go +++ b/schema/mysql/v57/version.go @@ -27,7 +27,7 @@ package v57 // NOTE: whenever there is a new database schema update, plz update the following versions // Version is the MySQL database release version -const Version = "1.9" +const Version = "1.21" // VisibilityVersion is the MySQL visibility database release version const VisibilityVersion = "1.1" diff --git a/schema/mysql/v8/temporal/versioned/v1.21/manifest.json b/schema/mysql/v8/temporal/versioned/v1.21/manifest.json new file mode 100644 index 00000000000..ccc86291369 --- /dev/null +++ b/schema/mysql/v8/temporal/versioned/v1.21/manifest.json @@ -0,0 +1,6 @@ +{ + "CurrVersion": "1.21", + "MinCompatibleVersion": "1.0", + "Description": "create task_queue_user_data table", + "SchemaUpdateCqlFiles": ["task_queue_user_data.sql"] +} diff --git a/schema/mysql/v8/temporal/versioned/v1.21/task_queue_user_data.sql b/schema/mysql/v8/temporal/versioned/v1.21/task_queue_user_data.sql new file mode 100644 index 00000000000..80926e417c8 --- /dev/null +++ b/schema/mysql/v8/temporal/versioned/v1.21/task_queue_user_data.sql @@ -0,0 +1,9 @@ +-- Stores task queue information such as user provided versioning data +CREATE TABLE task_queue_user_data ( + namespace_id BINARY(16) NOT NULL, + task_queue_name VARCHAR(255) NOT NULL, + data MEDIUMBLOB NOT NULL, -- temporal.server.api.persistence.v1.TaskQueueUserData + data_encoding VARCHAR(16) NOT NULL, -- Encoding type used for serialization, in practice this should always be proto3 + version BIGINT NOT NULL, -- Version of this row, used for optimistic concurrency + PRIMARY KEY (namespace_id, task_queue_name) +); diff --git a/schema/mysql/v8/version.go b/schema/mysql/v8/version.go index 7c053bc0f6f..25c0e1eaa6f 100644 --- a/schema/mysql/v8/version.go +++ b/schema/mysql/v8/version.go @@ -27,7 +27,7 @@ package v8 // NOTE: whenever there is a new database schema update, plz update the following versions // Version is the MySQL database release version -const Version = "1.9" +const Version = "1.21" // VisibilityVersion is the MySQL visibility database release version const VisibilityVersion = "1.3" diff --git a/schema/postgresql/v12/temporal/versioned/v1.21/manifest.json b/schema/postgresql/v12/temporal/versioned/v1.21/manifest.json new file mode 100644 index 00000000000..ccc86291369 --- /dev/null +++ b/schema/postgresql/v12/temporal/versioned/v1.21/manifest.json @@ -0,0 +1,6 @@ +{ + "CurrVersion": "1.21", + "MinCompatibleVersion": "1.0", + "Description": "create task_queue_user_data table", + "SchemaUpdateCqlFiles": ["task_queue_user_data.sql"] +} diff --git a/schema/postgresql/v12/temporal/versioned/v1.21/task_queue_user_data.sql b/schema/postgresql/v12/temporal/versioned/v1.21/task_queue_user_data.sql new file mode 100644 index 00000000000..bce7b9f6bb0 --- /dev/null +++ b/schema/postgresql/v12/temporal/versioned/v1.21/task_queue_user_data.sql @@ -0,0 +1,9 @@ +-- Stores task queue information such as user provided versioning data +CREATE TABLE task_queue_user_data ( + namespace_id BYTEA NOT NULL, + task_queue_name VARCHAR(255) NOT NULL, + data BYTEA NOT NULL, -- temporal.server.api.persistence.v1.TaskQueueUserData + data_encoding VARCHAR(16) NOT NULL, -- Encoding type used for serialization, in practice this should always be proto3 + version BIGINT NOT NULL, -- Version of this row, used for optimistic concurrency + PRIMARY KEY (namespace_id, task_queue_name) +); diff --git a/schema/postgresql/v12/version.go b/schema/postgresql/v12/version.go index 96aa84baae7..e56d5875265 100644 --- a/schema/postgresql/v12/version.go +++ b/schema/postgresql/v12/version.go @@ -28,7 +28,7 @@ package v12 // Version is the Postgres database release version // Temporal supports both MySQL and Postgres officially, so upgrade should be performed for both MySQL and Postgres -const Version = "1.9" +const Version = "1.21" // VisibilityVersion is the Postgres visibility database release version // Temporal supports both MySQL and Postgres officially, so upgrade should be performed for both MySQL and Postgres diff --git a/schema/postgresql/v96/temporal/versioned/v1.21/manifest.json b/schema/postgresql/v96/temporal/versioned/v1.21/manifest.json new file mode 100644 index 00000000000..ccc86291369 --- /dev/null +++ b/schema/postgresql/v96/temporal/versioned/v1.21/manifest.json @@ -0,0 +1,6 @@ +{ + "CurrVersion": "1.21", + "MinCompatibleVersion": "1.0", + "Description": "create task_queue_user_data table", + "SchemaUpdateCqlFiles": ["task_queue_user_data.sql"] +} diff --git a/schema/postgresql/v96/temporal/versioned/v1.21/task_queue_user_data.sql b/schema/postgresql/v96/temporal/versioned/v1.21/task_queue_user_data.sql new file mode 100644 index 00000000000..bce7b9f6bb0 --- /dev/null +++ b/schema/postgresql/v96/temporal/versioned/v1.21/task_queue_user_data.sql @@ -0,0 +1,9 @@ +-- Stores task queue information such as user provided versioning data +CREATE TABLE task_queue_user_data ( + namespace_id BYTEA NOT NULL, + task_queue_name VARCHAR(255) NOT NULL, + data BYTEA NOT NULL, -- temporal.server.api.persistence.v1.TaskQueueUserData + data_encoding VARCHAR(16) NOT NULL, -- Encoding type used for serialization, in practice this should always be proto3 + version BIGINT NOT NULL, -- Version of this row, used for optimistic concurrency + PRIMARY KEY (namespace_id, task_queue_name) +); diff --git a/schema/postgresql/v96/version.go b/schema/postgresql/v96/version.go index 9172a5a9e1e..8357aa7d4fa 100644 --- a/schema/postgresql/v96/version.go +++ b/schema/postgresql/v96/version.go @@ -28,7 +28,7 @@ package v96 // Version is the Postgres database release version // Temporal supports both MySQL and Postgres officially, so upgrade should be performed for both MySQL and Postgres -const Version = "1.9" +const Version = "1.21" // VisibilityVersion is the Postgres visibility database release version // Temporal supports both MySQL and Postgres officially, so upgrade should be performed for both MySQL and Postgres diff --git a/schema/sqlite/v3/temporal/versioned/v1.21/manifest.json b/schema/sqlite/v3/temporal/versioned/v1.21/manifest.json new file mode 100644 index 00000000000..ccc86291369 --- /dev/null +++ b/schema/sqlite/v3/temporal/versioned/v1.21/manifest.json @@ -0,0 +1,6 @@ +{ + "CurrVersion": "1.21", + "MinCompatibleVersion": "1.0", + "Description": "create task_queue_user_data table", + "SchemaUpdateCqlFiles": ["task_queue_user_data.sql"] +} diff --git a/schema/sqlite/v3/temporal/versioned/v1.21/task_queue_user_data.sql b/schema/sqlite/v3/temporal/versioned/v1.21/task_queue_user_data.sql new file mode 100644 index 00000000000..80926e417c8 --- /dev/null +++ b/schema/sqlite/v3/temporal/versioned/v1.21/task_queue_user_data.sql @@ -0,0 +1,9 @@ +-- Stores task queue information such as user provided versioning data +CREATE TABLE task_queue_user_data ( + namespace_id BINARY(16) NOT NULL, + task_queue_name VARCHAR(255) NOT NULL, + data MEDIUMBLOB NOT NULL, -- temporal.server.api.persistence.v1.TaskQueueUserData + data_encoding VARCHAR(16) NOT NULL, -- Encoding type used for serialization, in practice this should always be proto3 + version BIGINT NOT NULL, -- Version of this row, used for optimistic concurrency + PRIMARY KEY (namespace_id, task_queue_name) +); diff --git a/service/matching/config.go b/service/matching/config.go index b311a1f89c2..36d17dd9bc2 100644 --- a/service/matching/config.go +++ b/service/matching/config.go @@ -46,19 +46,20 @@ type ( // taskQueueManager configuration - RangeSize int64 - GetTasksBatchSize dynamicconfig.IntPropertyFnWithTaskQueueInfoFilters - UpdateAckInterval dynamicconfig.DurationPropertyFnWithTaskQueueInfoFilters - IdleTaskqueueCheckInterval dynamicconfig.DurationPropertyFnWithTaskQueueInfoFilters - MaxTaskqueueIdleTime dynamicconfig.DurationPropertyFnWithTaskQueueInfoFilters - NumTaskqueueWritePartitions dynamicconfig.IntPropertyFnWithTaskQueueInfoFilters - NumTaskqueueReadPartitions dynamicconfig.IntPropertyFnWithTaskQueueInfoFilters - ForwarderMaxOutstandingPolls dynamicconfig.IntPropertyFnWithTaskQueueInfoFilters - ForwarderMaxOutstandingTasks dynamicconfig.IntPropertyFnWithTaskQueueInfoFilters - ForwarderMaxRatePerSecond dynamicconfig.IntPropertyFnWithTaskQueueInfoFilters - ForwarderMaxChildrenPerNode dynamicconfig.IntPropertyFnWithTaskQueueInfoFilters - MaxVersionGraphSize dynamicconfig.IntPropertyFn - MetadataPollFrequency dynamicconfig.DurationPropertyFn + RangeSize int64 + GetTasksBatchSize dynamicconfig.IntPropertyFnWithTaskQueueInfoFilters + UpdateAckInterval dynamicconfig.DurationPropertyFnWithTaskQueueInfoFilters + IdleTaskqueueCheckInterval dynamicconfig.DurationPropertyFnWithTaskQueueInfoFilters + MaxTaskqueueIdleTime dynamicconfig.DurationPropertyFnWithTaskQueueInfoFilters + NumTaskqueueWritePartitions dynamicconfig.IntPropertyFnWithTaskQueueInfoFilters + NumTaskqueueReadPartitions dynamicconfig.IntPropertyFnWithTaskQueueInfoFilters + ForwarderMaxOutstandingPolls dynamicconfig.IntPropertyFnWithTaskQueueInfoFilters + ForwarderMaxOutstandingTasks dynamicconfig.IntPropertyFnWithTaskQueueInfoFilters + ForwarderMaxRatePerSecond dynamicconfig.IntPropertyFnWithTaskQueueInfoFilters + ForwarderMaxChildrenPerNode dynamicconfig.IntPropertyFnWithTaskQueueInfoFilters + VersionCompatibleSetLimitPerQueue dynamicconfig.IntPropertyFn + VersionBuildIDLimitPerQueue dynamicconfig.IntPropertyFn + UserDataPollFrequency dynamicconfig.DurationPropertyFn // Time to hold a poll request before returning an empty response if there are no tasks LongPollExpirationInterval dynamicconfig.DurationPropertyFnWithTaskQueueInfoFilters @@ -147,8 +148,9 @@ func NewConfig(dc *dynamicconfig.Collection) *Config { ForwarderMaxRatePerSecond: dc.GetIntPropertyFilteredByTaskQueueInfo(dynamicconfig.MatchingForwarderMaxRatePerSecond, 10), ForwarderMaxChildrenPerNode: dc.GetIntPropertyFilteredByTaskQueueInfo(dynamicconfig.MatchingForwarderMaxChildrenPerNode, 20), ShutdownDrainDuration: dc.GetDurationProperty(dynamicconfig.MatchingShutdownDrainDuration, 0*time.Second), - MaxVersionGraphSize: dc.GetIntProperty(dynamicconfig.VersionGraphNodeLimit, 1000), - MetadataPollFrequency: dc.GetDurationProperty(dynamicconfig.MatchingMetadataPollFrequency, 5*time.Minute), + VersionCompatibleSetLimitPerQueue: dc.GetIntProperty(dynamicconfig.VersionCompatibleSetLimitPerQueue, 10), + VersionBuildIDLimitPerQueue: dc.GetIntProperty(dynamicconfig.VersionBuildIDLimitPerQueue, 1000), + UserDataPollFrequency: dc.GetDurationProperty(dynamicconfig.MatchingUserDataPollFrequency, 5*time.Minute), AdminNamespaceToPartitionDispatchRate: dc.GetFloatPropertyFilteredByNamespace(dynamicconfig.AdminMatchingNamespaceToPartitionDispatchRate, 10000), AdminNamespaceTaskqueueToPartitionDispatchRate: dc.GetFloatPropertyFilteredByTaskQueueInfo(dynamicconfig.AdminMatchingNamespaceTaskqueueToPartitionDispatchRate, 1000), diff --git a/service/matching/configs/quotas.go b/service/matching/configs/quotas.go index 8af87afc536..f590e463842 100644 --- a/service/matching/configs/quotas.go +++ b/service/matching/configs/quotas.go @@ -41,8 +41,8 @@ var ( "RespondQueryTaskCompleted": 0, "GetWorkerBuildIdCompatibility": 0, "UpdateWorkerBuildIdCompatibility": 0, - "InvalidateTaskQueueMetadata": 0, - "GetTaskQueueMetadata": 0, + "InvalidateTaskQueueUserData": 0, + "GetTaskQueueUserData": 0, } APIPrioritiesOrdered = []int{0} diff --git a/service/matching/db.go b/service/matching/db.go index 0ffde9a381e..9ba41da1191 100644 --- a/service/matching/db.go +++ b/service/matching/db.go @@ -50,14 +50,14 @@ const ( type ( taskQueueDB struct { sync.Mutex - namespaceID namespace.ID - taskQueue *taskQueueID - taskQueueKind enumspb.TaskQueueKind - rangeID int64 - ackLevel int64 - versioningData *persistencespb.VersioningData - store persistence.TaskManager - logger log.Logger + namespaceID namespace.ID + taskQueue *taskQueueID + taskQueueKind enumspb.TaskQueueKind + rangeID int64 + ackLevel int64 + userData *persistencespb.VersionedTaskQueueUserData + store persistence.TaskManager + logger log.Logger } taskQueueState struct { rangeID int64 @@ -66,8 +66,8 @@ type ( ) var ( - errVersioningDataNotPresentOnPartition = errors.New("versioning data is only present on root workflow partition") - errVersioningDataNoMutateNonRoot = errors.New("can only mutate versioning data on root workflow task queue") + errUserDataNotPresentOnPartition = errors.New("user data is only present on root workflow partition") + errVersioningDataNoMutateNonRoot = errors.New("can only mutate versioning data on root workflow task queue") ) // newTaskQueueDB returns an instance of an object that represents @@ -130,7 +130,7 @@ func (db *taskQueueDB) takeOverTaskQueueLocked( response.TaskQueueInfo.Kind = db.taskQueueKind response.TaskQueueInfo.ExpiryTime = db.expiryTime() response.TaskQueueInfo.LastUpdateTime = timestamp.TimeNowPtrUtc() - _, err := db.updateTaskQueue(ctx, &persistence.UpdateTaskQueueRequest{ + _, err := db.store.UpdateTaskQueue(ctx, &persistence.UpdateTaskQueueRequest{ RangeID: response.RangeID + 1, TaskQueueInfo: response.TaskQueueInfo, PrevRangeID: response.RangeID, @@ -140,8 +140,11 @@ func (db *taskQueueDB) takeOverTaskQueueLocked( } db.ackLevel = response.TaskQueueInfo.AckLevel db.rangeID = response.RangeID + 1 - db.versioningData = response.TaskQueueInfo.VersioningData - return nil + _, err = db.getUserDataLocked(ctx) + if errors.Is(err, errUserDataNotPresentOnPartition) { + return nil + } + return err case *serviceerror.NotFound: if _, err := db.store.CreateTaskQueue(ctx, &persistence.CreateTaskQueueRequest{ @@ -151,7 +154,11 @@ func (db *taskQueueDB) takeOverTaskQueueLocked( return err } db.rangeID = initialRangeID - return nil + _, err = db.getUserDataLocked(ctx) + if errors.Is(err, errUserDataNotPresentOnPartition) { + return nil + } + return err default: return err @@ -162,7 +169,7 @@ func (db *taskQueueDB) renewTaskQueueLocked( ctx context.Context, rangeID int64, ) error { - if _, err := db.updateTaskQueue(ctx, &persistence.UpdateTaskQueueRequest{ + if _, err := db.store.UpdateTaskQueue(ctx, &persistence.UpdateTaskQueueRequest{ RangeID: rangeID, TaskQueueInfo: db.cachedQueueInfo(), PrevRangeID: db.rangeID, @@ -183,7 +190,7 @@ func (db *taskQueueDB) UpdateState( defer db.Unlock() queueInfo := db.cachedQueueInfo() queueInfo.AckLevel = ackLevel - _, err := db.updateTaskQueue(ctx, &persistence.UpdateTaskQueueRequest{ + _, err := db.store.UpdateTaskQueue(ctx, &persistence.UpdateTaskQueueRequest{ RangeID: db.rangeID, TaskQueueInfo: queueInfo, PrevRangeID: db.rangeID, @@ -281,99 +288,85 @@ func (db *taskQueueDB) CompleteTasksLessThan( return n, err } -// GetVersioningData returns the versioning data for this task queue. Do not mutate the returned pointer, as doing so +// GetUserData returns the versioning data for this task queue. Do not mutate the returned pointer, as doing so // will cause cache inconsistency. -func (db *taskQueueDB) GetVersioningData( +func (db *taskQueueDB) GetUserData( ctx context.Context, -) (*persistencespb.VersioningData, error) { +) (*persistencespb.VersionedTaskQueueUserData, error) { db.Lock() defer db.Unlock() - return db.getVersioningDataLocked(ctx) + return db.getUserDataLocked(ctx) } -// db.Lock() must be held before calling -func (db *taskQueueDB) getVersioningDataLocked( +// db.Lock() must be held before calling. +// Returns in-memory cached value or reads from DB and updates the cached value. +func (db *taskQueueDB) getUserDataLocked( ctx context.Context, -) (*persistencespb.VersioningData, error) { - if db.versioningData != nil { - return db.versioningData, nil - } - - if !db.taskQueue.IsRoot() || db.taskQueue.taskType != enumspb.TASK_QUEUE_TYPE_WORKFLOW { - return nil, errVersioningDataNotPresentOnPartition - } +) (*persistencespb.VersionedTaskQueueUserData, error) { + if db.userData == nil { + if !db.taskQueue.IsRoot() || db.taskQueue.taskType != enumspb.TASK_QUEUE_TYPE_WORKFLOW { + return nil, errUserDataNotPresentOnPartition + } - tqInfo, err := db.store.GetTaskQueue(ctx, &persistence.GetTaskQueueRequest{ - NamespaceID: db.namespaceID.String(), - TaskQueue: db.taskQueue.FullName(), - TaskType: db.taskQueue.taskType, - }) - if err != nil { - return nil, err + response, err := db.store.GetTaskQueueUserData(ctx, &persistence.GetTaskQueueUserDataRequest{ + NamespaceID: db.namespaceID.String(), + TaskQueue: db.taskQueue.BaseNameString(), + }) + if err != nil { + var notFoundError *serviceerror.NotFound + if errors.As(err, ¬FoundError) { + return nil, nil + } + return nil, err + } + db.userData = response.UserData } - db.versioningData = tqInfo.TaskQueueInfo.GetVersioningData() - return tqInfo.TaskQueueInfo.GetVersioningData(), nil + return db.userData, nil } -// MutateVersioningData allows callers to update versioning data for this task queue. The pointer passed to the -// mutating function is guaranteed to be non-nil. +// UpdateUserData allows callers to update user data (such as worker build IDs) for this task queue. The pointer passed +// to the update function is guaranteed to be non-nil. +// Note that the user data's clock may be nil and should be initialized externally where there's access to the cluster +// metadata and the cluster ID can be obtained. // -// On success returns a pointer to the updated data (which must not be mutated). -func (db *taskQueueDB) MutateVersioningData(ctx context.Context, mutator func(*persistencespb.VersioningData) error) (*persistencespb.VersioningData, error) { +// On success returns a pointer to the updated data, which must *not* be mutated. +func (db *taskQueueDB) UpdateUserData(ctx context.Context, updateFn func(*persistencespb.TaskQueueUserData) (*persistencespb.TaskQueueUserData, error)) (*persistencespb.VersionedTaskQueueUserData, error) { if !db.taskQueue.IsRoot() || db.taskQueue.taskType != enumspb.TASK_QUEUE_TYPE_WORKFLOW { return nil, errVersioningDataNoMutateNonRoot } db.Lock() defer db.Unlock() - verDat, err := db.getVersioningDataLocked(ctx) + userData, err := db.getUserDataLocked(ctx) if err != nil { return nil, err } - if verDat == nil { - verDat = &persistencespb.VersioningData{} + preUpdateData := userData.GetData() + if preUpdateData == nil { + preUpdateData = &persistencespb.TaskQueueUserData{} } - if err := mutator(verDat); err != nil { + updatedUserData, err := updateFn(preUpdateData) + if err != nil { return nil, err } - - queueInfo := db.cachedQueueInfo() - queueInfo.VersioningData = verDat - - _, err = db.updateTaskQueue(ctx, &persistence.UpdateTaskQueueRequest{ - RangeID: db.rangeID, - TaskQueueInfo: queueInfo, - PrevRangeID: db.rangeID, + err = db.store.UpdateTaskQueueUserData(ctx, &persistence.UpdateTaskQueueUserDataRequest{ + NamespaceID: db.namespaceID.String(), + TaskQueue: db.cachedQueueInfo().Name, + UserData: &persistencespb.VersionedTaskQueueUserData{Version: userData.GetVersion(), Data: updatedUserData}, }) if err == nil { - db.versioningData = verDat + db.userData = &persistencespb.VersionedTaskQueueUserData{Version: userData.GetVersion() + 1, Data: updatedUserData} } - return verDat, err + // TODO: Put a message in the namespace replication queue + return db.userData, err } -func (db *taskQueueDB) setVersioningDataForNonRootPartition(verDat *persistencespb.VersioningData) { +func (db *taskQueueDB) setUserDataForNonRootPartition(userData *persistencespb.VersionedTaskQueueUserData) { db.Lock() defer db.Unlock() - db.versioningData = verDat -} - -// Use this rather than calling UpdateTaskQueue directly on the store -func (db *taskQueueDB) updateTaskQueue( - ctx context.Context, - request *persistence.UpdateTaskQueueRequest, -) (*persistence.UpdateTaskQueueResponse, error) { - reqToPersist := request - // Only the root task queue stores versioning information - if !db.taskQueue.IsRoot() { - tqInfoSansVerDat := *request.TaskQueueInfo - tqInfoSansVerDat.VersioningData = nil - reqClone := *request - reqClone.TaskQueueInfo = &tqInfoSansVerDat - reqToPersist = &reqClone - } - return db.store.UpdateTaskQueue(ctx, reqToPersist) + db.userData = userData } func (db *taskQueueDB) expiryTime() *time.Time { @@ -394,7 +387,6 @@ func (db *taskQueueDB) cachedQueueInfo() *persistencespb.TaskQueueInfo { TaskType: db.taskQueue.taskType, Kind: db.taskQueueKind, AckLevel: db.ackLevel, - VersioningData: db.versioningData, ExpiryTime: db.expiryTime(), LastUpdateTime: timestamp.TimeNowPtrUtc(), } diff --git a/service/matching/handler.go b/service/matching/handler.go index f8ce7cdb492..eb3d60b4627 100644 --- a/service/matching/handler.go +++ b/service/matching/handler.go @@ -367,10 +367,10 @@ func (h *Handler) GetWorkerBuildIdCompatibility( } // InvalidateTaskQueueMetadata notifies a task queue that some data has changed, and should be invalidated/refreshed -func (h *Handler) InvalidateTaskQueueMetadata( +func (h *Handler) InvalidateTaskQueueUserData( ctx context.Context, - request *matchingservice.InvalidateTaskQueueMetadataRequest, -) (_ *matchingservice.InvalidateTaskQueueMetadataResponse, retError error) { + request *matchingservice.InvalidateTaskQueueUserDataRequest, +) (_ *matchingservice.InvalidateTaskQueueUserDataResponse, retError error) { defer log.CapturePanic(h.logger, &retError) hCtx := h.newHandlerContext( ctx, @@ -379,16 +379,16 @@ func (h *Handler) InvalidateTaskQueueMetadata( Name: request.GetTaskQueue(), Kind: enumspb.TASK_QUEUE_KIND_NORMAL, }, - metrics.MatchingInvalidateTaskQueueMetadataScope, + metrics.MatchingInvalidateTaskQueueUserDataScope, ) - return h.engine.InvalidateTaskQueueMetadata(hCtx, request) + return h.engine.InvalidateTaskQueueUserData(hCtx, request) } -func (h *Handler) GetTaskQueueMetadata( +func (h *Handler) GetTaskQueueUserData( ctx context.Context, - request *matchingservice.GetTaskQueueMetadataRequest, -) (_ *matchingservice.GetTaskQueueMetadataResponse, retError error) { + request *matchingservice.GetTaskQueueUserDataRequest, +) (_ *matchingservice.GetTaskQueueUserDataResponse, retError error) { defer log.CapturePanic(h.logger, &retError) hCtx := h.newHandlerContext( ctx, @@ -397,10 +397,10 @@ func (h *Handler) GetTaskQueueMetadata( Name: request.GetTaskQueue(), Kind: enumspb.TASK_QUEUE_KIND_NORMAL, }, - metrics.MatchingGetTaskQueueMetadataScope, + metrics.MatchingGetTaskQueueUserDataScope, ) - return h.engine.GetTaskQueueMetadata(hCtx, request) + return h.engine.GetTaskQueueUserData(hCtx, request) } func (h *Handler) namespaceName(id namespace.ID) namespace.Name { diff --git a/service/matching/matchingEngine.go b/service/matching/matchingEngine.go index 6140e3b5bfa..8e4c81e1e17 100644 --- a/service/matching/matchingEngine.go +++ b/service/matching/matchingEngine.go @@ -720,8 +720,28 @@ func (e *matchingEngineImpl) UpdateWorkerBuildIdCompatibility( if err != nil { return nil, err } - err = tqMgr.MutateVersioningData(hCtx.Context, func(data *persistencespb.VersioningData) error { - return UpdateVersionSets(data, req.GetRequest(), e.config.MaxVersionGraphSize()) + err = tqMgr.UpdateUserData(hCtx.Context, func(data *persistencespb.TaskQueueUserData) (*persistencespb.TaskQueueUserData, error) { + clock := data.GetClock() + if clock == nil { + tmp := zeroHLC(e.clusterMeta.GetClusterID()) + clock = &tmp + } + + updatedClock, versioningData, err := UpdateVersionSets( + *clock, + data.GetVersioningData(), + req.GetRequest(), + e.config.VersionCompatibleSetLimitPerQueue(), + e.config.VersionBuildIDLimitPerQueue(), + ) + if err != nil { + return nil, err + } + // Avoid mutation + ret := *data + ret.Clock = &updatedClock + ret.VersioningData = versioningData + return &ret, nil }) if err != nil { return nil, err @@ -746,7 +766,7 @@ func (e *matchingEngineImpl) GetWorkerBuildIdCompatibility( } return nil, err } - verDat, err := tqMgr.GetVersioningData(hCtx.Context) + userData, err := tqMgr.GetUserData(hCtx.Context) if err != nil { if _, ok := err.(*serviceerror.NotFound); ok { return &matchingservice.GetWorkerBuildIdCompatibilityResponse{}, nil @@ -754,14 +774,14 @@ func (e *matchingEngineImpl) GetWorkerBuildIdCompatibility( return nil, err } return &matchingservice.GetWorkerBuildIdCompatibilityResponse{ - Response: ToBuildIdOrderingResponse(verDat, int(req.GetRequest().GetMaxSets())), + Response: ToBuildIdOrderingResponse(userData.GetData().GetVersioningData(), int(req.GetRequest().GetMaxSets())), }, nil } -func (e *matchingEngineImpl) InvalidateTaskQueueMetadata( +func (e *matchingEngineImpl) InvalidateTaskQueueUserData( hCtx *handlerContext, - req *matchingservice.InvalidateTaskQueueMetadataRequest, -) (*matchingservice.InvalidateTaskQueueMetadataResponse, error) { + req *matchingservice.InvalidateTaskQueueUserDataRequest, +) (*matchingservice.InvalidateTaskQueueUserDataResponse, error) { taskQueue, err := newTaskQueueID(namespace.ID(req.GetNamespaceId()), req.GetTaskQueue(), req.GetTaskQueueType()) if err != nil { return nil, err @@ -769,22 +789,22 @@ func (e *matchingEngineImpl) InvalidateTaskQueueMetadata( tqMgr, err := e.getTaskQueueManager(hCtx, taskQueue, enumspb.TASK_QUEUE_KIND_NORMAL, false) if tqMgr == nil && err == nil { // Task queue is not currently loaded, so nothing to do here - return &matchingservice.InvalidateTaskQueueMetadataResponse{}, nil + return &matchingservice.InvalidateTaskQueueUserDataResponse{}, nil } if err != nil { return nil, err } - err = tqMgr.InvalidateMetadata(req) + err = tqMgr.InvalidateUserData(req) if err != nil { return nil, err } - return &matchingservice.InvalidateTaskQueueMetadataResponse{}, nil + return &matchingservice.InvalidateTaskQueueUserDataResponse{}, nil } -func (e *matchingEngineImpl) GetTaskQueueMetadata( +func (e *matchingEngineImpl) GetTaskQueueUserData( hCtx *handlerContext, - req *matchingservice.GetTaskQueueMetadataRequest, -) (*matchingservice.GetTaskQueueMetadataResponse, error) { + req *matchingservice.GetTaskQueueUserDataRequest, +) (*matchingservice.GetTaskQueueUserDataResponse, error) { namespaceID := namespace.ID(req.GetNamespaceId()) taskQueueName := req.GetTaskQueue() taskQueue, err := newTaskQueueID(namespaceID, taskQueueName, enumspb.TASK_QUEUE_TYPE_WORKFLOW) @@ -795,19 +815,24 @@ func (e *matchingEngineImpl) GetTaskQueueMetadata( if err != nil { return nil, err } - resp := &matchingservice.GetTaskQueueMetadataResponse{} - verDatHash := req.GetWantVersioningDataCurhash() - // This isn't != nil, because gogoproto will round-trip serialize an empty byte array in a request - // into a nil field. - if len(verDatHash) > 0 { - vDat, err := tqMgr.GetVersioningData(hCtx) - if err != nil { - return nil, err + version := req.GetLastKnownUserDataVersion() + if version < 0 { + return nil, serviceerror.NewInvalidArgument("last_known_user_data_version must not be negative") + } + resp := &matchingservice.GetTaskQueueUserDataResponse{} + userData, err := tqMgr.GetUserData(hCtx) + if err != nil { + return nil, err + } + if userData != nil { + resp.TaskQueueHasUserData = true + if userData.Version > version { + resp.UserData = userData } - if !bytes.Equal(HashVersioningData(vDat), verDatHash) { - resp.VersioningDataResp = &matchingservice.GetTaskQueueMetadataResponse_VersioningData{ - VersioningData: vDat, - } + if userData.Version < version { + // This is highly unlikely but may happen due to an edge case in during ownership transfer. + // We rely on periodic refresh and client retries in this case to let the system eventually self-heal. + return nil, serviceerror.NewFailedPrecondition("Non-root partition requested task queue user data for version greater than known version") } } return resp, nil diff --git a/service/matching/matchingEngineInterfaces.go b/service/matching/matchingEngineInterfaces.go index 01e003c2c99..56aac4610a2 100644 --- a/service/matching/matchingEngineInterfaces.go +++ b/service/matching/matchingEngineInterfaces.go @@ -43,7 +43,7 @@ type ( ListTaskQueuePartitions(hCtx *handlerContext, request *matchingservice.ListTaskQueuePartitionsRequest) (*matchingservice.ListTaskQueuePartitionsResponse, error) UpdateWorkerBuildIdCompatibility(ctx *handlerContext, request *matchingservice.UpdateWorkerBuildIdCompatibilityRequest) (*matchingservice.UpdateWorkerBuildIdCompatibilityResponse, error) GetWorkerBuildIdCompatibility(ctx *handlerContext, request *matchingservice.GetWorkerBuildIdCompatibilityRequest) (*matchingservice.GetWorkerBuildIdCompatibilityResponse, error) - InvalidateTaskQueueMetadata(ctx *handlerContext, request *matchingservice.InvalidateTaskQueueMetadataRequest) (*matchingservice.InvalidateTaskQueueMetadataResponse, error) - GetTaskQueueMetadata(ctx *handlerContext, request *matchingservice.GetTaskQueueMetadataRequest) (*matchingservice.GetTaskQueueMetadataResponse, error) + InvalidateTaskQueueUserData(ctx *handlerContext, request *matchingservice.InvalidateTaskQueueUserDataRequest) (*matchingservice.InvalidateTaskQueueUserDataResponse, error) + GetTaskQueueUserData(ctx *handlerContext, request *matchingservice.GetTaskQueueUserDataRequest) (*matchingservice.GetTaskQueueUserDataResponse, error) } ) diff --git a/service/matching/matchingEngine_test.go b/service/matching/matchingEngine_test.go index c3f28cb2498..41a4ad9fa32 100644 --- a/service/matching/matchingEngine_test.go +++ b/service/matching/matchingEngine_test.go @@ -110,8 +110,8 @@ func (s *matchingEngineSuite) SetupTest() { s.controller = gomock.NewController(s.T()) s.mockHistoryClient = historyservicemock.NewMockHistoryServiceClient(s.controller) s.mockMatchingClient = matchingservicemock.NewMockMatchingServiceClient(s.controller) - s.mockMatchingClient.EXPECT().GetTaskQueueMetadata(gomock.Any(), gomock.Any()). - Return(&matchingservice.GetTaskQueueMetadataResponse{}, nil).AnyTimes() + s.mockMatchingClient.EXPECT().GetTaskQueueUserData(gomock.Any(), gomock.Any()). + Return(&matchingservice.GetTaskQueueUserDataResponse{}, nil).AnyTimes() s.taskManager = newTestTaskManager(s.logger) s.mockNamespaceCache = namespace.NewMockRegistry(s.controller) ns := namespace.NewLocalNamespaceForTest(&persistencespb.NamespaceInfo{Name: matchingTestNamespace}, nil, "") @@ -1911,7 +1911,7 @@ func (s *matchingEngineSuite) TestTaskExpiryAndCompletion() { } func (s *matchingEngineSuite) TestGetVersioningData() { - s.mockMatchingClient.EXPECT().InvalidateTaskQueueMetadata(gomock.Any(), gomock.Any()).Return(nil, nil).AnyTimes() + s.mockMatchingClient.EXPECT().InvalidateTaskQueueUserData(gomock.Any(), gomock.Any()).Return(nil, nil).AnyTimes() namespaceID := namespace.ID(uuid.New()) tq := "tupac" @@ -1928,7 +1928,7 @@ func (s *matchingEngineSuite) TestGetVersioningData() { s.NotNil(res) // Set a long list of versions - for i := 0; i < 100; i++ { + for i := 0; i < 10; i++ { id := fmt.Sprintf("%d", i) res, err := s.matchingEngine.UpdateWorkerBuildIdCompatibility(s.handlerContext, &matchingservice.UpdateWorkerBuildIdCompatibilityRequest{ NamespaceId: namespaceID.String(), @@ -1944,11 +1944,11 @@ func (s *matchingEngineSuite) TestGetVersioningData() { s.NotNil(res) } // Make a long compat-versions chain - for i := 0; i < 10; i++ { - id := fmt.Sprintf("99.%d", i) - prevCompat := fmt.Sprintf("99.%d", i-1) + for i := 0; i < 100; i++ { + id := fmt.Sprintf("9.%d", i) + prevCompat := fmt.Sprintf("9.%d", i-1) if i == 0 { - prevCompat = "99" + prevCompat = "9" } res, err := s.matchingEngine.UpdateWorkerBuildIdCompatibility(s.handlerContext, &matchingservice.UpdateWorkerBuildIdCompatibilityRequest{ NamespaceId: namespaceID.String(), @@ -1981,9 +1981,9 @@ func (s *matchingEngineSuite) TestGetVersioningData() { majorSets := res.GetResponse().GetMajorVersionSets() curDefault := majorSets[len(majorSets)-1] s.NotNil(curDefault) - s.Equal("99", curDefault.GetBuildIds()[0]) + s.Equal("9", curDefault.GetBuildIds()[0]) lastNode := curDefault.GetBuildIds()[len(curDefault.GetBuildIds())-1] - s.Equal("99.9", lastNode) + s.Equal("9.99", lastNode) s.Equal("0", majorSets[0].GetBuildIds()[0]) // Ensure depth limiting works @@ -1998,9 +1998,9 @@ func (s *matchingEngineSuite) TestGetVersioningData() { s.NoError(err) majorSets = res.GetResponse().GetMajorVersionSets() curDefault = majorSets[len(majorSets)-1] - s.Equal("99", curDefault.GetBuildIds()[0]) + s.Equal("9", curDefault.GetBuildIds()[0]) lastNode = curDefault.GetBuildIds()[len(curDefault.GetBuildIds())-1] - s.Equal("99.9", lastNode) + s.Equal("9.99", lastNode) s.Equal(1, len(majorSets)) res, err = s.matchingEngine.GetWorkerBuildIdCompatibility(s.handlerContext, &matchingservice.GetWorkerBuildIdCompatibilityRequest{ @@ -2013,14 +2013,14 @@ func (s *matchingEngineSuite) TestGetVersioningData() { }) s.NoError(err) majorSets = res.GetResponse().GetMajorVersionSets() - s.Equal("95", majorSets[0].GetBuildIds()[0]) + s.Equal("5", majorSets[0].GetBuildIds()[0]) } func (s *matchingEngineSuite) TestActivityQueueMetadataInvalidate() { // Overwrite the matching mock - we expect one and only one fetch call here, after the activity queue is invalidated mockMatch := matchingservicemock.NewMockMatchingServiceClient(s.controller) - mockMatch.EXPECT().GetTaskQueueMetadata(gomock.Any(), gomock.Any()). - Return(&matchingservice.GetTaskQueueMetadataResponse{}, nil). + mockMatch.EXPECT().GetTaskQueueUserData(gomock.Any(), gomock.Any()). + Return(&matchingservice.GetTaskQueueUserDataResponse{}, nil). Times(1) s.matchingEngine.matchingClient = mockMatch @@ -2044,12 +2044,13 @@ func (s *matchingEngineSuite) TestActivityQueueMetadataInvalidate() { s.NoError(err) s.NotNil(ttqm) - _, err = s.matchingEngine.InvalidateTaskQueueMetadata(s.handlerContext, &matchingservice.InvalidateTaskQueueMetadataRequest{ + _, err = s.matchingEngine.InvalidateTaskQueueUserData(s.handlerContext, &matchingservice.InvalidateTaskQueueUserDataRequest{ NamespaceId: namespaceID.String(), TaskQueue: tq, TaskQueueType: enumspb.TASK_QUEUE_TYPE_ACTIVITY, - VersioningData: &persistencespb.VersioningData{ - VersionSets: []*taskqueuepb.CompatibleVersionSet{mkNewSet("hi")}, + UserData: &persistencespb.VersionedTaskQueueUserData{ + Version: 1, + Data: mkUserData(1), }, }) s.NoError(err) @@ -2163,6 +2164,7 @@ type testTaskQueueManager struct { createTaskCount int getTasksCount int tasks *treemap.Map + userData *persistencespb.VersionedTaskQueueUserData } func (m *testTaskQueueManager) RangeID() int64 { @@ -2442,6 +2444,21 @@ func (m *testTaskManager) String() string { return result } +// GetTaskQueueData implements persistence.TaskManager +func (m *testTaskManager) GetTaskQueueUserData(ctx context.Context, request *persistence.GetTaskQueueUserDataRequest) (*persistence.GetTaskQueueUserDataResponse, error) { + tlm := m.getTaskQueueManager(newTestTaskQueueID(namespace.ID(request.NamespaceID), request.TaskQueue, enumspb.TASK_QUEUE_TYPE_WORKFLOW)) + return &persistence.GetTaskQueueUserDataResponse{ + UserData: tlm.userData, + }, nil +} + +// UpdateTaskQueueUserData implements persistence.TaskManager +func (m *testTaskManager) UpdateTaskQueueUserData(ctx context.Context, request *persistence.UpdateTaskQueueUserDataRequest) error { + tlm := m.getTaskQueueManager(newTestTaskQueueID(namespace.ID(request.NamespaceID), request.TaskQueue, enumspb.TASK_QUEUE_TYPE_WORKFLOW)) + tlm.userData = request.UserData + return nil +} + func validateTimeRange(t time.Time, expectedDuration time.Duration) bool { currentTime := time.Now().UTC() diff := time.Duration(currentTime.UnixNano() - t.UnixNano()) diff --git a/service/matching/taskQueueManager.go b/service/matching/taskQueueManager.go index d64826e240e..ddc978cfd41 100644 --- a/service/matching/taskQueueManager.go +++ b/service/matching/taskQueueManager.go @@ -114,12 +114,13 @@ type ( // DispatchQueryTask will dispatch query to local or remote poller. If forwarded then result or error is returned, // if dispatched to local poller then nil and nil is returned. DispatchQueryTask(ctx context.Context, taskID string, request *matchingservice.QueryWorkflowRequest) (*matchingservice.QueryWorkflowResponse, error) - // GetVersioningData returns the versioning data for this task queue - GetVersioningData(ctx context.Context) (*persistencespb.VersioningData, error) - // MutateVersioningData allows callers to update versioning data for this task queue - MutateVersioningData(ctx context.Context, mutator func(*persistencespb.VersioningData) error) error - // InvalidateMetadata allows callers to invalidate cached data on this task queue - InvalidateMetadata(request *matchingservice.InvalidateTaskQueueMetadataRequest) error + // GetUserData returns the verioned user data for this task queue + GetUserData(ctx context.Context) (*persistencespb.VersionedTaskQueueUserData, error) + // UpdateUserData allows callers to update user data for this task queue + // Extra care should be taken to avoid mutating the existing data in the update function. + UpdateUserData(ctx context.Context, updateFn func(*persistencespb.TaskQueueUserData) (*persistencespb.TaskQueueUserData, error)) error + // InvalidateUserData allows callers to invalidate cached data on this task queue + InvalidateUserData(request *matchingservice.InvalidateTaskQueueUserDataRequest) error CancelPoller(pollerID string) GetAllPollerInfo() []*taskqueuepb.PollerInfo HasPollerAfter(accessTime time.Time) bool @@ -161,9 +162,9 @@ type ( signalFatalProblem func(taskQueueManager) clusterMeta cluster.Metadata initializedError *future.FutureImpl[struct{}] - // metadataInitialFetch is fulfilled once versioning data is fetched from the root partition. If this TQ is + // userDataInitialFetch is fulfilled once versioning data is fetched from the root partition. If this TQ is // the root partition, it is fulfilled as soon as it is fetched from db. - metadataInitialFetch *future.FutureImpl[struct{}] + userDataInitialFetch *future.FutureImpl[struct{}] metadataPoller metadataPoller } @@ -232,10 +233,10 @@ func newTaskQueueManager( namespace: nsName, taggedMetricsHandler: taggedMetricsHandler, initializedError: future.NewFuture[struct{}](), - metadataInitialFetch: future.NewFuture[struct{}](), + userDataInitialFetch: future.NewFuture[struct{}](), metadataPoller: metadataPoller{ running: uberatomic.NewBool(false), - pollIntervalCfgFn: e.config.MetadataPollFrequency, + pollIntervalCfgFn: e.config.UserDataPollFrequency, stopChan: make(chan struct{}), }, } @@ -288,7 +289,7 @@ func (c *taskQueueManagerImpl) Start() { c.liveness.Start() c.taskWriter.Start() c.taskReader.Start() - go c.fetchMetadataFromRootPartitionOnInit(context.TODO()) + go c.fetchUserDataFromRootPartitionOnInit(context.TODO()) c.logger.Info("", tag.LifeCycleStarted) c.taggedMetricsHandler.Counter(metrics.TaskQueueStartedCounter.GetMetricName()).Record(1) } @@ -329,7 +330,7 @@ func (c *taskQueueManagerImpl) WaitUntilInitialized(ctx context.Context) error { } // We don't really care if the initial fetch worked or not, anything that *requires* a bit of metadata should fail // that operation if it's never fetched OK. If the initial fetch errored, the metadataPoller will have been started. - _, _ = c.metadataInitialFetch.Get(ctx) + _, _ = c.userDataInitialFetch.Get(ctx) return err } @@ -467,19 +468,19 @@ func (c *taskQueueManagerImpl) DispatchQueryTask( // GetVersioningData returns the versioning data for the task queue if any. If this task queue is a sub-partition and // has no cached data, it will explicitly attempt a fetch from the root partition. -func (c *taskQueueManagerImpl) GetVersioningData(ctx context.Context) (*persistencespb.VersioningData, error) { - vd, err := c.db.GetVersioningData(ctx) - if errors.Is(err, errVersioningDataNotPresentOnPartition) { +func (c *taskQueueManagerImpl) GetUserData(ctx context.Context) (*persistencespb.VersionedTaskQueueUserData, error) { + data, err := c.db.GetUserData(ctx) + if errors.Is(err, errUserDataNotPresentOnPartition) { // If this is a non-root-partition with no versioning data, this call is indicating we might expect to find // some. Since we may not have started the poller, we want to explicitly attempt to fetch now, because // it's possible some was added to the root partition, but it failed to invalidate this partition. - return c.fetchMetadataFromRootPartition(ctx) + return c.fetchUserDataFromRootPartition(ctx) } - return vd, err + return data, err } -func (c *taskQueueManagerImpl) MutateVersioningData(ctx context.Context, mutator func(*persistencespb.VersioningData) error) error { - newDat, err := c.db.MutateVersioningData(ctx, mutator) +func (c *taskQueueManagerImpl) UpdateUserData(ctx context.Context, updateFn func(*persistencespb.TaskQueueUserData) (*persistencespb.TaskQueueUserData, error)) error { + newDat, err := c.db.UpdateUserData(ctx, updateFn) c.signalIfFatal(err) if err != nil { return err @@ -496,12 +497,12 @@ func (c *taskQueueManagerImpl) MutateVersioningData(ctx context.Context, mutator wg.Add(1) go func(i int, tqt enumspb.TaskQueueType) { tq := c.taskQueueID.WithPartition(i).FullName() - _, err := c.matchingClient.InvalidateTaskQueueMetadata(ctx, - &matchingservice.InvalidateTaskQueueMetadataRequest{ - NamespaceId: c.taskQueueID.namespaceID.String(), - TaskQueue: tq, - TaskQueueType: tqt, - VersioningData: newDat, + _, err := c.matchingClient.InvalidateTaskQueueUserData(ctx, + &matchingservice.InvalidateTaskQueueUserDataRequest{ + NamespaceId: c.taskQueueID.namespaceID.String(), + TaskQueue: tq, + TaskQueueType: tqt, + UserData: newDat, }) if err != nil { c.logger.Warn("Failed to notify sub-partition of invalidated versioning data", @@ -515,14 +516,14 @@ func (c *taskQueueManagerImpl) MutateVersioningData(ctx context.Context, mutator return nil } -func (c *taskQueueManagerImpl) InvalidateMetadata(request *matchingservice.InvalidateTaskQueueMetadataRequest) error { - if request.GetVersioningData() != nil { +func (c *taskQueueManagerImpl) InvalidateUserData(request *matchingservice.InvalidateTaskQueueUserDataRequest) error { + if request.GetUserData() != nil { if c.taskQueueID.IsRoot() && c.taskQueueID.taskType == enumspb.TASK_QUEUE_TYPE_WORKFLOW { // Should never happen. Root partitions do not get their versioning data invalidated. c.logger.Warn("A root workflow partition was told to invalidate its versioning data, this should not happen") return nil } - c.db.setVersioningDataForNonRootPartition(request.GetVersioningData()) + c.db.setUserDataForNonRootPartition(request.GetUserData()) c.metadataPoller.StartIfUnstarted() } return nil @@ -725,54 +726,49 @@ func (c *taskQueueManagerImpl) newIOContext() (context.Context, context.CancelFu return ctx, cancel } -func (c *taskQueueManagerImpl) fetchMetadataFromRootPartitionOnInit(ctx context.Context) { - if c.metadataInitialFetch.Ready() { +func (c *taskQueueManagerImpl) fetchUserDataFromRootPartitionOnInit(ctx context.Context) { + if c.userDataInitialFetch.Ready() { return } - _, err := c.fetchMetadataFromRootPartition(ctx) - c.metadataInitialFetch.Set(struct{}{}, err) + _, err := c.fetchUserDataFromRootPartition(ctx) + c.userDataInitialFetch.Set(struct{}{}, err) } -// fetchMetadataFromRootPartition fetches metadata from root partition iff this partition is not a root partition. +// fetchUserDataFromRootPartition fetches user data from root partition iff this partition is not a root partition. // Returns the fetched data, if fetching was necessary and successful. -func (c *taskQueueManagerImpl) fetchMetadataFromRootPartition(ctx context.Context) (*persistencespb.VersioningData, error) { +func (c *taskQueueManagerImpl) fetchUserDataFromRootPartition(ctx context.Context) (*persistencespb.VersionedTaskQueueUserData, error) { // Nothing to do if we are the root partition of a workflow queue, since we should own the data. // (for versioning - any later added metadata may need to not abort so early) if c.taskQueueID.IsRoot() && c.taskQueueID.taskType == enumspb.TASK_QUEUE_TYPE_WORKFLOW { return nil, nil } - curDat, err := c.db.GetVersioningData(ctx) - if err != nil && !errors.Is(err, errVersioningDataNotPresentOnPartition) { + knownUserData, err := c.db.GetUserData(ctx) + if err != nil && !errors.Is(err, errUserDataNotPresentOnPartition) { return nil, err } - curHash := HashVersioningData(curDat) rootTqName := c.taskQueueID.Root().FullName() - if len(curHash) == 0 { - // if we have no data, make sure we send a sigil value, so it's known we desire versioning data - curHash = []byte{0} - } - res, err := c.matchingClient.GetTaskQueueMetadata(ctx, &matchingservice.GetTaskQueueMetadataRequest{ - NamespaceId: c.taskQueueID.namespaceID.String(), - TaskQueue: rootTqName, - WantVersioningDataCurhash: curHash, + res, err := c.matchingClient.GetTaskQueueUserData(ctx, &matchingservice.GetTaskQueueUserDataRequest{ + NamespaceId: c.taskQueueID.namespaceID.String(), + TaskQueue: rootTqName, + LastKnownUserDataVersion: knownUserData.GetVersion(), }) // If the root partition returns nil here, then that means our data matched, and we don't need to update. // If it's nil because it never existed, then we'd never have any data. // It can't be nil due to removing versions, as that would result in a non-nil container with // nil inner fields. - if !res.GetMatchedReqHash() { - c.db.setVersioningDataForNonRootPartition(res.GetVersioningData()) + if res.GetUserData() != nil { + c.db.setUserDataForNonRootPartition(res.GetUserData()) } // We want to start the poller as long as the root partition has any kind of data (or fetching hasn't worked) - if res.GetMatchedReqHash() || res.GetVersioningData() != nil || err != nil { + if res.GetUserData() != nil || err != nil { c.metadataPoller.StartIfUnstarted() } if err != nil { return nil, err } - return res.GetVersioningData(), nil + return res.GetUserData(), nil } // StartIfUnstarted starts the poller if it's not already started. The passed in function is called repeatedly @@ -797,7 +793,7 @@ func (mp *metadataPoller) pollLoop() { case <-ticker.C: // In case the interval has changed ticker.Reset(mp.pollIntervalCfgFn()) - dat, err := mp.tqMgr.fetchMetadataFromRootPartition(context.TODO()) + dat, err := mp.tqMgr.fetchUserDataFromRootPartition(context.TODO()) if dat == nil && err == nil { // Can stop polling since there is no versioning data. Loop will be restarted if we // are told to invalidate the data, or we attempt to fetch it via GetVersioningData. diff --git a/service/matching/taskQueueManager_test.go b/service/matching/taskQueueManager_test.go index 29a1bf2dfc1..ef81a12ce57 100644 --- a/service/matching/taskQueueManager_test.go +++ b/service/matching/taskQueueManager_test.go @@ -41,7 +41,6 @@ import ( "github.com/stretchr/testify/require" commonpb "go.temporal.io/api/common/v1" enumspb "go.temporal.io/api/enums/v1" - taskqueuepb "go.temporal.io/api/taskqueue/v1" enumsspb "go.temporal.io/server/api/enums/v1" persistencespb "go.temporal.io/server/api/persistence/v1" @@ -358,6 +357,7 @@ func TestIsTaskAddedRecently(t *testing.T) { tlm := mustCreateTestTaskQueueManager(t, controller) require.True(t, tlm.taskReader.isTaskAddedRecently(time.Now().UTC())) + // TODO: this fails when run locally, not sure why require.False(t, tlm.taskReader.isTaskAddedRecently(time.Now().UTC().Add(-tlm.config.MaxTaskqueueIdleTime()))) require.True(t, tlm.taskReader.isTaskAddedRecently(time.Now().UTC().Add(1*time.Second))) require.False(t, tlm.taskReader.isTaskAddedRecently(time.Time{})) @@ -503,7 +503,7 @@ func TestAddTaskStandby(t *testing.T) { require.False(t, syncMatch) } -func TestTaskQueueSubParitionFetchesVersioningInfoFromRootPartitionOnInit(t *testing.T) { +func TestTaskQueueSubParitionFetchesUserDataFromRootPartitionOnInit(t *testing.T) { controller := gomock.NewController(t) defer controller.Finish() ctx := context.Background() @@ -512,37 +512,36 @@ func TestTaskQueueSubParitionFetchesVersioningInfoFromRootPartitionOnInit(t *tes tqCfg := defaultTqmTestOpts(controller) tqCfg.tqId = subTqId - data := &persistencespb.VersioningData{ - VersionSets: []*taskqueuepb.CompatibleVersionSet{mkNewSet("0")}, + data := &persistencespb.VersionedTaskQueueUserData{ + Version: 1, + Data: mkUserData(1), } - asResp := &matchingservice.GetTaskQueueMetadataResponse{ - VersioningDataResp: &matchingservice.GetTaskQueueMetadataResponse_VersioningData{ - VersioningData: data, - }, + asResp := &matchingservice.GetTaskQueueUserDataResponse{ + TaskQueueHasUserData: true, + UserData: data, } subTq := mustCreateTestTaskQueueManagerWithConfig(t, controller, tqCfg, func(tqm *taskQueueManagerImpl) { mockMatchingClient := matchingservicemock.NewMockMatchingServiceClient(controller) - mockMatchingClient.EXPECT().GetTaskQueueMetadata(gomock.Any(), - gomock.Eq(&matchingservice.GetTaskQueueMetadataRequest{ - NamespaceId: defaultNamespaceId.String(), - TaskQueue: defaultRootTqID, - // Nonsense value since it has nothing on startup - WantVersioningDataCurhash: []byte{0}, + mockMatchingClient.EXPECT().GetTaskQueueUserData(gomock.Any(), + gomock.Eq(&matchingservice.GetTaskQueueUserDataRequest{ + NamespaceId: defaultNamespaceId.String(), + TaskQueue: defaultRootTqID, + LastKnownUserDataVersion: 0, })). Return(asResp, nil) tqm.matchingClient = mockMatchingClient }) subTq.Start() require.NoError(t, subTq.WaitUntilInitialized(ctx)) - verDat, err := subTq.GetVersioningData(ctx) + userData, err := subTq.GetUserData(ctx) require.NoError(t, err) - require.Equal(t, data, verDat) + require.Equal(t, data, userData) subTq.Stop() } -func TestTaskQueueSubParitionSendsCurrentHashOfVersioningDataWhenFetching(t *testing.T) { +func TestTaskQueueSubParitionSendsLastKnownVersionOfUserDataWhenFetching(t *testing.T) { controller := gomock.NewController(t) defer controller.Finish() ctx := context.Background() @@ -551,34 +550,32 @@ func TestTaskQueueSubParitionSendsCurrentHashOfVersioningDataWhenFetching(t *tes tqCfg := defaultTqmTestOpts(controller) tqCfg.tqId = subTqId - data := &persistencespb.VersioningData{ - VersionSets: []*taskqueuepb.CompatibleVersionSet{mkNewSet("0")}, + data := &persistencespb.VersionedTaskQueueUserData{ + Version: 2, + Data: mkUserData(1), } - asResp := &matchingservice.GetTaskQueueMetadataResponse{ - VersioningDataResp: &matchingservice.GetTaskQueueMetadataResponse_VersioningData{ - VersioningData: data, - }, + asResp := &matchingservice.GetTaskQueueUserDataResponse{ + TaskQueueHasUserData: true, + UserData: data, } - dataHash := HashVersioningData(data) subTq := mustCreateTestTaskQueueManagerWithConfig(t, controller, tqCfg, func(tqm *taskQueueManagerImpl) { mockMatchingClient := matchingservicemock.NewMockMatchingServiceClient(controller) - mockMatchingClient.EXPECT().GetTaskQueueMetadata(gomock.Any(), - gomock.Eq(&matchingservice.GetTaskQueueMetadataRequest{ - NamespaceId: defaultNamespaceId.String(), - TaskQueue: defaultRootTqID, - WantVersioningDataCurhash: dataHash, + mockMatchingClient.EXPECT().GetTaskQueueUserData(gomock.Any(), + gomock.Eq(&matchingservice.GetTaskQueueUserDataRequest{ + NamespaceId: defaultNamespaceId.String(), + TaskQueue: defaultRootTqID, + LastKnownUserDataVersion: 0, })). Return(asResp, nil) tqm.matchingClient = mockMatchingClient }) - // Cram some versioning data in there so it will have something to hash when fetching - subTq.db.versioningData = data // Don't start it. Just explicitly call fetching function. - res, err := subTq.fetchMetadataFromRootPartition(ctx) + res, err := subTq.fetchUserDataFromRootPartition(ctx) require.NotNil(t, res) require.NoError(t, err) + assert.Equal(t, data, subTq.db.userData) } type invalidateMatcher struct { @@ -586,7 +583,7 @@ type invalidateMatcher struct { } func (m invalidateMatcher) Matches(x interface{}) bool { - v, ok := x.(*matchingservice.InvalidateTaskQueueMetadataRequest) + v, ok := x.(*matchingservice.InvalidateTaskQueueUserDataRequest) return ok && v.GetTaskQueueType() == m.matchesTaskQType } func (m invalidateMatcher) String() string { @@ -601,13 +598,13 @@ func TestTaskQueueRootPartitionNotifiesChildrenOfInvalidation(t *testing.T) { rootTq := mustCreateTestTaskQueueManagerWithConfig(t, controller, defaultTqmTestOpts(controller), func(tqm *taskQueueManagerImpl) { mockMatchingClient := matchingservicemock.NewMockMatchingServiceClient(controller) - mockMatchingClient.EXPECT().InvalidateTaskQueueMetadata( + mockMatchingClient.EXPECT().InvalidateTaskQueueUserData( gomock.Any(), invalidateMatcher{matchesTaskQType: enumspb.TASK_QUEUE_TYPE_WORKFLOW}). - Return(&matchingservice.InvalidateTaskQueueMetadataResponse{}, nil). + Return(&matchingservice.InvalidateTaskQueueUserDataResponse{}, nil). Times(tqm.config.NumReadPartitions() - 1) - mockMatchingClient.EXPECT().InvalidateTaskQueueMetadata( + mockMatchingClient.EXPECT().InvalidateTaskQueueUserData( gomock.Any(), invalidateMatcher{matchesTaskQType: enumspb.TASK_QUEUE_TYPE_ACTIVITY}). - Return(&matchingservice.InvalidateTaskQueueMetadataResponse{}, nil). + Return(&matchingservice.InvalidateTaskQueueUserDataResponse{}, nil). // Not minus 1 here because root activity partition gets invalidated Times(tqm.config.NumReadPartitions()) tqm.matchingClient = mockMatchingClient @@ -616,11 +613,8 @@ func TestTaskQueueRootPartitionNotifiesChildrenOfInvalidation(t *testing.T) { rootTq.Start() require.NoError(t, rootTq.WaitUntilInitialized(ctx)) // Make a change, mock verifies children are invalidated - require.NoError(t, rootTq.MutateVersioningData(ctx, func(vd *persistencespb.VersioningData) error { - *vd = persistencespb.VersioningData{ - VersionSets: []*taskqueuepb.CompatibleVersionSet{mkNewSet("0")}, - } - return nil + require.NoError(t, rootTq.UpdateUserData(ctx, func(vd *persistencespb.TaskQueueUserData) (*persistencespb.TaskQueueUserData, error) { + return mkUserData(1), nil })) rootTq.Stop() } @@ -633,26 +627,26 @@ func TestTaskQueueSubPartitionPollsPeriodically(t *testing.T) { require.NoError(t, err) tqCfg := defaultTqmTestOpts(controller) tqCfg.tqId = subTqId - tqCfg.config.MetadataPollFrequency = func() time.Duration { + tqCfg.config.UserDataPollFrequency = func() time.Duration { return time.Millisecond * 10 } - asResp := &matchingservice.GetTaskQueueMetadataResponse{ - VersioningDataResp: &matchingservice.GetTaskQueueMetadataResponse_VersioningData{ - VersioningData: &persistencespb.VersioningData{ - VersionSets: []*taskqueuepb.CompatibleVersionSet{mkNewSet("0")}, - }, + asResp := &matchingservice.GetTaskQueueUserDataResponse{ + TaskQueueHasUserData: true, + UserData: &persistencespb.VersionedTaskQueueUserData{ + Version: 1, + Data: mkUserData(1), }, } subTq := mustCreateTestTaskQueueManagerWithConfig(t, controller, tqCfg, func(tqm *taskQueueManagerImpl) { mockMatchingClient := matchingservicemock.NewMockMatchingServiceClient(controller) - mockMatchingClient.EXPECT().GetTaskQueueMetadata(gomock.Any(), gomock.Any()). + mockMatchingClient.EXPECT().GetTaskQueueUserData(gomock.Any(), gomock.Any()). Return(asResp, nil).MinTimes(3) tqm.matchingClient = mockMatchingClient }) - res, err := subTq.fetchMetadataFromRootPartition(ctx) + res, err := subTq.fetchUserDataFromRootPartition(ctx) require.NotNil(t, res) require.NoError(t, err) // Wait a bit to make sure we poll a few times @@ -668,45 +662,44 @@ func TestTaskQueueSubPartitionDoesNotPollIfNoDataThenPollsWhenInvalidated(t *tes require.NoError(t, err) tqCfg := defaultTqmTestOpts(controller) tqCfg.tqId = subTqId - tqCfg.config.MetadataPollFrequency = func() time.Duration { + tqCfg.config.UserDataPollFrequency = func() time.Duration { return time.Millisecond * 10 } - nilDatResp := &matchingservice.GetTaskQueueMetadataResponse{ - VersioningDataResp: &matchingservice.GetTaskQueueMetadataResponse_VersioningData{ - VersioningData: nil, - }, + nilDatResp := &matchingservice.GetTaskQueueUserDataResponse{ + TaskQueueHasUserData: false, } - verDat := &persistencespb.VersioningData{ - VersionSets: []*taskqueuepb.CompatibleVersionSet{mkNewSet("0")}, + userData := mkUserData(1) + verionedUserData := &persistencespb.VersionedTaskQueueUserData{ + Version: 1, + Data: userData, } - hasDatResp := &matchingservice.GetTaskQueueMetadataResponse{ - VersioningDataResp: &matchingservice.GetTaskQueueMetadataResponse_VersioningData{ - VersioningData: verDat, - }, + hasDatResp := &matchingservice.GetTaskQueueUserDataResponse{ + TaskQueueHasUserData: true, + UserData: verionedUserData, } subTq := mustCreateTestTaskQueueManagerWithConfig(t, controller, tqCfg, func(tqm *taskQueueManagerImpl) { mockMatchingClient := matchingservicemock.NewMockMatchingServiceClient(controller) - mockMatchingClient.EXPECT().GetTaskQueueMetadata(gomock.Any(), gomock.Any()). + mockMatchingClient.EXPECT().GetTaskQueueUserData(gomock.Any(), gomock.Any()). Return(nilDatResp, nil).Times(2) - mockMatchingClient.EXPECT().GetTaskQueueMetadata(gomock.Any(), gomock.Any()). + mockMatchingClient.EXPECT().GetTaskQueueUserData(gomock.Any(), gomock.Any()). Return(hasDatResp, nil).MinTimes(1) tqm.matchingClient = mockMatchingClient }) - res, err := subTq.fetchMetadataFromRootPartition(ctx) + res, err := subTq.fetchUserDataFromRootPartition(ctx) require.Nil(t, res) require.NoError(t, err) // Wait a bit to make sure we *don't* end up polling (if we do, mock will fail with >2 fetches) time.Sleep(time.Millisecond * 25) // Explicitly try to get versioning data. Since we don't have any cached, it'll explicitly fetch. - vDat, err := subTq.GetVersioningData(ctx) + existingData, err := subTq.GetUserData(ctx) require.NoError(t, err) - require.Nil(t, vDat) + require.Nil(t, existingData) // Now invalidate, the poll loop should be started, so we'll see at least one more mock call - err = subTq.InvalidateMetadata(&matchingservice.InvalidateTaskQueueMetadataRequest{ - VersioningData: verDat, + err = subTq.InvalidateUserData(&matchingservice.InvalidateTaskQueueUserDataRequest{ + UserData: verionedUserData, }) require.NoError(t, err) time.Sleep(time.Millisecond * 20) @@ -720,31 +713,32 @@ func TestTaskQueueManagerWaitInitFailThenPass(t *testing.T) { require.NoError(t, err) tqCfg := defaultTqmTestOpts(controller) tqCfg.tqId = subTqId - tqCfg.config.MetadataPollFrequency = func() time.Duration { + tqCfg.config.UserDataPollFrequency = func() time.Duration { return time.Millisecond * 10 } - data := &persistencespb.VersioningData{ - VersionSets: []*taskqueuepb.CompatibleVersionSet{mkNewSet("0")}, + data := mkUserData(1) + versionedData := &persistencespb.VersionedTaskQueueUserData{ + Version: 1, + Data: data, } - asResp := &matchingservice.GetTaskQueueMetadataResponse{ - VersioningDataResp: &matchingservice.GetTaskQueueMetadataResponse_VersioningData{ - VersioningData: data, - }, + asResp := &matchingservice.GetTaskQueueUserDataResponse{ + TaskQueueHasUserData: true, + UserData: versionedData, } mockMatchingClient := matchingservicemock.NewMockMatchingServiceClient(controller) tq := mustCreateTestTaskQueueManagerWithConfig(t, controller, tqCfg, func(tqm *taskQueueManagerImpl) { - mockMatchingClient.EXPECT().GetTaskQueueMetadata(gomock.Any(), gomock.Any()). + mockMatchingClient.EXPECT().GetTaskQueueUserData(gomock.Any(), gomock.Any()). Return(nil, errors.New("some error")).Times(1) - mockMatchingClient.EXPECT().GetTaskQueueMetadata(gomock.Any(), gomock.Any()). + mockMatchingClient.EXPECT().GetTaskQueueUserData(gomock.Any(), gomock.Any()). Return(asResp, nil).Times(1) tqm.matchingClient = mockMatchingClient }) tq.Start() - // This does not error even if initial metadata fetch fails (and it does, here) + // This does not error even if initial user data fetch fails (and it does, here) require.NoError(t, tq.WaitUntilInitialized(ctx)) // Wait long enough for poller retry to happen time.Sleep(time.Millisecond * 15) @@ -752,13 +746,13 @@ func TestTaskQueueManagerWaitInitFailThenPass(t *testing.T) { // call hasn't happened yet. controller.Finish() // Get the data and see it's set - dat, err := tq.GetVersioningData(ctx) + dat, err := tq.GetUserData(ctx) require.NoError(t, err) - require.Equal(t, data, dat) + require.Equal(t, versionedData, dat) tq.Stop() } -func TestFetchingVersioningDataErrorsIfNeverFetchedFromRootSuccessfully(t *testing.T) { +func TestFetchingUserDataErrorsIfNeverFetchedFromRootSuccessfully(t *testing.T) { controller := gomock.NewController(t) defer controller.Finish() ctx := context.Background() @@ -766,38 +760,39 @@ func TestFetchingVersioningDataErrorsIfNeverFetchedFromRootSuccessfully(t *testi require.NoError(t, err) tqCfg := defaultTqmTestOpts(controller) tqCfg.tqId = subTqId - tqCfg.config.MetadataPollFrequency = func() time.Duration { + tqCfg.config.UserDataPollFrequency = func() time.Duration { return time.Millisecond * 10 } subTq := mustCreateTestTaskQueueManagerWithConfig(t, controller, tqCfg, func(tqm *taskQueueManagerImpl) { mockMatchingClient := matchingservicemock.NewMockMatchingServiceClient(controller) - mockMatchingClient.EXPECT().GetTaskQueueMetadata(gomock.Any(), gomock.Any()). + mockMatchingClient.EXPECT().GetTaskQueueUserData(gomock.Any(), gomock.Any()). Return(nil, errors.New("fetching broken!")).AnyTimes() tqm.matchingClient = mockMatchingClient }) subTq.Start() require.NoError(t, subTq.WaitUntilInitialized(ctx)) for i := 0; i < 10; i++ { - _, err := subTq.GetVersioningData(ctx) + _, err := subTq.GetUserData(ctx) require.Error(t, err) time.Sleep(time.Millisecond * 2) } } -func TestActivityQueueGetsVersioningDataFromWorkflowQueue(t *testing.T) { +func TestActivityQueueGetsUserDataFromWorkflowQueue(t *testing.T) { controller := gomock.NewController(t) defer controller.Finish() ctx := context.Background() - data := &persistencespb.VersioningData{ - VersionSets: []*taskqueuepb.CompatibleVersionSet{mkNewSet("0")}, + data := mkUserData(1) + versionedData := &persistencespb.VersionedTaskQueueUserData{ + Version: 1, + Data: data, } - asResp := &matchingservice.GetTaskQueueMetadataResponse{ - VersioningDataResp: &matchingservice.GetTaskQueueMetadataResponse_VersioningData{ - VersioningData: data, - }, + asResp := &matchingservice.GetTaskQueueUserDataResponse{ + TaskQueueHasUserData: true, + UserData: versionedData, } tqCfg := defaultTqmTestOpts(controller) @@ -805,7 +800,7 @@ func TestActivityQueueGetsVersioningDataFromWorkflowQueue(t *testing.T) { actTq := mustCreateTestTaskQueueManagerWithConfig(t, controller, tqCfg, func(tqm *taskQueueManagerImpl) { mockMatchingClient := matchingservicemock.NewMockMatchingServiceClient(controller) - mockMatchingClient.EXPECT().GetTaskQueueMetadata(gomock.Any(), gomock.Any()). + mockMatchingClient.EXPECT().GetTaskQueueUserData(gomock.Any(), gomock.Any()). Return(asResp, nil).Times(1) tqm.matchingClient = mockMatchingClient }) @@ -819,25 +814,25 @@ func TestActivityQueueGetsVersioningDataFromWorkflowQueue(t *testing.T) { actTqPart := mustCreateTestTaskQueueManagerWithConfig(t, controller, tqCfg, func(tqm *taskQueueManagerImpl) { mockMatchingClient := matchingservicemock.NewMockMatchingServiceClient(controller) - mockMatchingClient.EXPECT().GetTaskQueueMetadata(gomock.Any(), gomock.Any()). + mockMatchingClient.EXPECT().GetTaskQueueUserData(gomock.Any(), gomock.Any()). Return(asResp, nil).Times(1) tqm.matchingClient = mockMatchingClient }) actTqPart.Start() require.NoError(t, actTqPart.WaitUntilInitialized(ctx)) - verDat, err := actTq.GetVersioningData(ctx) + actTqData, err := actTq.GetUserData(ctx) require.NoError(t, err) - require.Equal(t, data, verDat) - verDat, err = actTqPart.GetVersioningData(ctx) + require.Equal(t, versionedData, actTqData) + actTqData, err = actTqPart.GetUserData(ctx) require.NoError(t, err) - require.Equal(t, data, verDat) + require.Equal(t, versionedData, actTqData) actTq.Stop() actTqPart.Stop() } -func TestMutateOnNonRootFails(t *testing.T) { +func TestUpdateOnNonRootFails(t *testing.T) { controller := gomock.NewController(t) defer controller.Finish() ctx := context.Background() @@ -847,7 +842,9 @@ func TestMutateOnNonRootFails(t *testing.T) { tqCfg := defaultTqmTestOpts(controller) tqCfg.tqId = subTqId subTq := mustCreateTestTaskQueueManagerWithConfig(t, controller, tqCfg) - err = subTq.MutateVersioningData(ctx, func(data *persistencespb.VersioningData) error { return nil }) + err = subTq.UpdateUserData(ctx, func(data *persistencespb.TaskQueueUserData) (*persistencespb.TaskQueueUserData, error) { + return data, nil + }) require.Error(t, err) require.ErrorIs(t, err, errVersioningDataNoMutateNonRoot) @@ -856,7 +853,9 @@ func TestMutateOnNonRootFails(t *testing.T) { actTqCfg := defaultTqmTestOpts(controller) actTqCfg.tqId = actTqId actTq := mustCreateTestTaskQueueManagerWithConfig(t, controller, actTqCfg) - err = actTq.MutateVersioningData(ctx, func(data *persistencespb.VersioningData) error { return nil }) + err = actTq.UpdateUserData(ctx, func(data *persistencespb.TaskQueueUserData) (*persistencespb.TaskQueueUserData, error) { + return data, nil + }) require.Error(t, err) require.ErrorIs(t, err, errVersioningDataNoMutateNonRoot) } diff --git a/service/matching/version_sets.go b/service/matching/version_sets.go index 1cf14bd7e79..91c4e70d900 100644 --- a/service/matching/version_sets.go +++ b/service/matching/version_sets.go @@ -27,17 +27,34 @@ package matching import ( "encoding/binary" "fmt" + "time" "github.com/dgryski/go-farm" "go.temporal.io/api/serviceerror" - taskqueuepb "go.temporal.io/api/taskqueue/v1" + "go.temporal.io/api/taskqueue/v1" "go.temporal.io/api/workflowservice/v1" + clockpb "go.temporal.io/server/api/clock/v1" "go.temporal.io/server/api/persistence/v1" - "go.temporal.io/server/common/util" ) -func ToBuildIdOrderingResponse(g *persistence.VersioningData, maxDepth int) *workflowservice.GetWorkerBuildIdCompatibilityResponse { - return depthLimiter(g, maxDepth) +// ToBuildIdOrderingResponse transforms the internal VersioningData representation to public representation. +// If maxSets is given, the last sets up to maxSets will be returned. +func ToBuildIdOrderingResponse(data *persistence.VersioningData, maxSets int) *workflowservice.GetWorkerBuildIdCompatibilityResponse { + lenSets := len(data.GetVersionSets()) + numSets := lenSets + if maxSets > 0 && numSets > maxSets { + numSets = maxSets + } + versionSets := make([]*taskqueue.CompatibleVersionSet, numSets) + for i := range versionSets { + set := data.GetVersionSets()[i+lenSets-numSets] + buildIds := make([]string, len(set.GetBuildIds())) + for j, version := range set.GetBuildIds() { + buildIds[j] = version.Id + } + versionSets[i] = &taskqueue.CompatibleVersionSet{BuildIds: buildIds} + } + return &workflowservice.GetWorkerBuildIdCompatibilityResponse{MajorVersionSets: versionSets} } // HashVersioningData returns a farm.Fingerprint64 hash of the versioning data as bytes. If the data is nonexistent or @@ -55,15 +72,25 @@ func HashVersioningData(data *persistence.VersioningData) []byte { return b } -func depthLimiter(g *persistence.VersioningData, maxDepth int) *workflowservice.GetWorkerBuildIdCompatibilityResponse { +func checkLimits(g *persistence.VersioningData, maxSets, maxBuildIDs int) error { sets := g.GetVersionSets() - if maxDepth > 0 { - sets = util.SliceTail(sets, maxDepth) + if maxSets > 0 && len(sets) > maxSets { + return serviceerror.NewFailedPrecondition(fmt.Sprintf("update would exceed number of compatible version sets permitted in namespace dynamic config (%v/%v)", len(sets), maxSets)) + } + if maxBuildIDs == 0 { + return nil + } + numBuildIDs := 0 + for _, set := range sets { + numBuildIDs += len(set.GetBuildIds()) } - return &workflowservice.GetWorkerBuildIdCompatibilityResponse{MajorVersionSets: sets} + if numBuildIDs > maxBuildIDs { + return serviceerror.NewFailedPrecondition(fmt.Sprintf("update would exceed number of build IDs permitted in namespace dynamic config (%v/%v)", numBuildIDs, maxBuildIDs)) + } + return nil } -// Given existing versioning data and an update request, update the version sets appropriately. The request is expected +// UpdateVersionSets updates version sets given existing versioning data and an update request. The request is expected // to have already been validated. // // See the API docs for more detail. In short, the versioning data representation consists of a sequence of sequences of @@ -87,68 +114,86 @@ func depthLimiter(g *persistence.VersioningData, maxDepth int) *workflowservice. // default for that set. // 3. Target some existing version, marking it (and thus its set) as the default set. // -// Deletions are not permitted, as inserting new versions can accomplish the same goals with less complexity. However, -// sets may be dropped when the number of sets limit is reached. They are dropped oldest first - the current default set -// is never dropped, instead dropping the next oldest set. -func UpdateVersionSets(existingData *persistence.VersioningData, req *workflowservice.UpdateWorkerBuildIdCompatibilityRequest, maxSize int) error { - err := updateImpl(existingData, req) +// Deletions are performed by a background process which verifies build IDs are no longer in use and safe to delete (not yet implemented). +// +// Update may fail with FailedPrecondition if it would cause exceeding the supplied limits. +func UpdateVersionSets(clock clockpb.HybridLogicalClock, data *persistence.VersioningData, req *workflowservice.UpdateWorkerBuildIdCompatibilityRequest, maxSets, maxBuildIDs int) (clockpb.HybridLogicalClock, *persistence.VersioningData, error) { + clock = generateHLCTimestamp(clock) + data, err := updateImpl(clock, data, req) if err != nil { - return err + return clock, nil, err } - // Limit graph size if it's grown too large - newResp := depthLimiter(existingData, maxSize) - existingData.VersionSets = newResp.GetMajorVersionSets() - return nil + if err := checkLimits(data, maxSets, maxBuildIDs); err != nil { + return clock, nil, err + } + return clock, data, nil } //nolint:revive // cyclomatic complexity -func updateImpl(existingData *persistence.VersioningData, req *workflowservice.UpdateWorkerBuildIdCompatibilityRequest) error { +func updateImpl(timestamp clockpb.HybridLogicalClock, existingData *persistence.VersioningData, req *workflowservice.UpdateWorkerBuildIdCompatibilityRequest) (*persistence.VersioningData, error) { // First find if the targeted version is already in the sets targetedVersion := extractTargetedVersion(req) findRes := findVersion(existingData, targetedVersion) targetSetIdx, versionInSetIdx := findRes.setIdx, findRes.indexInSet + modifiedData := persistence.VersioningData{ + VersionSets: make([]*persistence.CompatibleVersionSet, len(existingData.GetVersionSets())), + DefaultUpdateTimestamp: existingData.GetDefaultUpdateTimestamp(), + } + copy(modifiedData.VersionSets, existingData.GetVersionSets()) if req.GetAddNewBuildIdInNewDefaultSet() != "" { // If it's not already in the sets, add it as the new default set if targetSetIdx != -1 { - return serviceerror.NewInvalidArgument(fmt.Sprintf("version %s already exists", targetedVersion)) + return nil, serviceerror.NewInvalidArgument(fmt.Sprintf("version %s already exists", targetedVersion)) } - existingData.VersionSets = append(existingData.GetVersionSets(), &taskqueuepb.CompatibleVersionSet{ - BuildIds: []string{targetedVersion}, + modifiedData.VersionSets = append(modifiedData.VersionSets, &persistence.CompatibleVersionSet{ + SetIds: []string{targetedVersion}, + BuildIds: []*persistence.BuildID{{Id: targetedVersion, State: persistence.STATE_ACTIVE, StateUpdateTimestamp: ×tamp}}, }) + makeVersionInSetDefault(&modifiedData, len(modifiedData.VersionSets)-1, 0, ×tamp) + makeDefaultSet(&modifiedData, len(modifiedData.VersionSets)-1, ×tamp) } else if addNew := req.GetAddNewCompatibleBuildId(); addNew != nil { compatVer := addNew.GetExistingCompatibleBuildId() - compatSetIdx := findVersion(existingData, compatVer).setIdx + compatSetIdx := findVersion(&modifiedData, compatVer).setIdx if compatSetIdx == -1 { - return serviceerror.NewNotFound( + return nil, serviceerror.NewNotFound( fmt.Sprintf("targeted compatible_version %v not found", compatVer)) } if targetSetIdx != -1 { // If the version does exist, this operation can't do anything meaningful, but we can fail if the user // says the version is now compatible with some different set. - return serviceerror.NewInvalidArgument(fmt.Sprintf("version %s already exists", targetedVersion)) + return nil, serviceerror.NewInvalidArgument(fmt.Sprintf("version %s already exists", targetedVersion)) } + // First duplicate the build IDs to avoid mutation + lastIdx := len(existingData.VersionSets[compatSetIdx].BuildIds) + modifiedData.VersionSets[compatSetIdx] = &persistence.CompatibleVersionSet{ + SetIds: existingData.VersionSets[compatSetIdx].SetIds, + BuildIds: make([]*persistence.BuildID, lastIdx+1), + } + copy(modifiedData.VersionSets[compatSetIdx].BuildIds, existingData.VersionSets[compatSetIdx].BuildIds) + // If the version doesn't exist, add it to the compatible set - existingData.VersionSets[compatSetIdx].BuildIds = - append(existingData.VersionSets[compatSetIdx].BuildIds, targetedVersion) + modifiedData.VersionSets[compatSetIdx].BuildIds[lastIdx] = + &persistence.BuildID{Id: targetedVersion, State: persistence.STATE_ACTIVE, StateUpdateTimestamp: ×tamp} + makeVersionInSetDefault(&modifiedData, compatSetIdx, lastIdx, ×tamp) if addNew.GetMakeSetDefault() { - makeDefaultSet(existingData, compatSetIdx) + makeDefaultSet(&modifiedData, compatSetIdx, ×tamp) } } else if req.GetPromoteSetByBuildId() != "" { if targetSetIdx == -1 { - return serviceerror.NewNotFound(fmt.Sprintf("targeted version %v not found", targetedVersion)) + return nil, serviceerror.NewNotFound(fmt.Sprintf("targeted version %v not found", targetedVersion)) } - makeDefaultSet(existingData, targetSetIdx) + makeDefaultSet(&modifiedData, targetSetIdx, ×tamp) } else if req.GetPromoteBuildIdWithinSet() != "" { if targetSetIdx == -1 { - return serviceerror.NewNotFound(fmt.Sprintf("targeted version %v not found", targetedVersion)) + return nil, serviceerror.NewNotFound(fmt.Sprintf("targeted version %v not found", targetedVersion)) } - makeVersionInSetDefault(existingData, targetSetIdx, versionInSetIdx) + makeVersionInSetDefault(&modifiedData, targetSetIdx, versionInSetIdx, ×tamp) } - return nil + return &modifiedData, nil } func extractTargetedVersion(req *workflowservice.UpdateWorkerBuildIdCompatibilityRequest) string { @@ -172,7 +217,7 @@ type findVersionRes struct { func findVersion(data *persistence.VersioningData, buildID string) findVersionRes { for setIx, set := range data.GetVersionSets() { for versionIx, version := range set.GetBuildIds() { - if version == buildID { + if version.Id == buildID { return findVersionRes{ setIdx: setIx, indexInSet: versionIx, @@ -186,22 +231,50 @@ func findVersion(data *persistence.VersioningData, buildID string) findVersionRe } } -func makeDefaultSet(data *persistence.VersioningData, setIx int) { +func makeDefaultSet(data *persistence.VersioningData, setIx int, timestamp *clockpb.HybridLogicalClock) { + data.DefaultUpdateTimestamp = timestamp if len(data.VersionSets) <= 1 { return } - // Move the set to the end and shift all the others down - moveMe := data.VersionSets[setIx] - copy(data.VersionSets[setIx:], data.VersionSets[setIx+1:]) - data.VersionSets[len(data.VersionSets)-1] = moveMe + if setIx < len(data.VersionSets)-1 { + // Move the set to the end and shift all the others down + moveMe := data.VersionSets[setIx] + copy(data.VersionSets[setIx:], data.VersionSets[setIx+1:]) + data.VersionSets[len(data.VersionSets)-1] = moveMe + } } -func makeVersionInSetDefault(data *persistence.VersioningData, setIx, versionIx int) { +func makeVersionInSetDefault(data *persistence.VersioningData, setIx, versionIx int, timestamp *clockpb.HybridLogicalClock) { + data.VersionSets[setIx].DefaultUpdateTimestamp = timestamp setVersions := data.VersionSets[setIx].BuildIds if len(setVersions) <= 1 { return } - moveMe := setVersions[versionIx] - copy(setVersions[versionIx:], setVersions[versionIx+1:]) - setVersions[len(setVersions)-1] = moveMe + if versionIx < len(setVersions)-1 { + // Move the build ID to the end and shift all the others down + moveMe := setVersions[versionIx] + copy(setVersions[versionIx:], setVersions[versionIx+1:]) + setVersions[len(setVersions)-1] = moveMe + } +} + +func generateHLCTimestamp(clock clockpb.HybridLogicalClock) clockpb.HybridLogicalClock { + wallclock := time.Now().UnixMilli() + // Ensure time does not move backwards + if wallclock < clock.GetWallClock() { + wallclock = clock.GetWallClock() + } + // Ensure timestamp is monotonically increasing + if wallclock == clock.GetWallClock() { + clock.Version = clock.GetVersion() + 1 + } else { + clock.Version = 0 + clock.WallClock = wallclock + } + + return clockpb.HybridLogicalClock{WallClock: wallclock, Version: clock.Version, ClusterId: clock.ClusterId} +} + +func zeroHLC(clusterID int64) clockpb.HybridLogicalClock { + return clockpb.HybridLogicalClock{WallClock: 0, Version: 0, ClusterId: clusterID} } diff --git a/service/matching/version_sets_test.go b/service/matching/version_sets_test.go index 7bf1e1a8258..5b71c38f0e4 100644 --- a/service/matching/version_sets_test.go +++ b/service/matching/version_sets_test.go @@ -33,22 +33,34 @@ import ( "go.temporal.io/api/serviceerror" taskqueuepb "go.temporal.io/api/taskqueue/v1" "go.temporal.io/api/workflowservice/v1" + clockpb "go.temporal.io/server/api/clock/v1" persistencepb "go.temporal.io/server/api/persistence/v1" ) -func mkNewSet(id string) *taskqueuepb.CompatibleVersionSet { - return &taskqueuepb.CompatibleVersionSet{ - BuildIds: []string{id}, +func mkNewSet(id string, clock clockpb.HybridLogicalClock) *persistencepb.CompatibleVersionSet { + return &persistencepb.CompatibleVersionSet{ + SetIds: []string{id}, + BuildIds: []*persistencepb.BuildID{{Id: id, State: persistencepb.STATE_ACTIVE, StateUpdateTimestamp: &clock}}, + DefaultUpdateTimestamp: &clock, } } -func mkInitialData(numSets int) *persistencepb.VersioningData { - sets := make([]*taskqueuepb.CompatibleVersionSet, numSets) +func mkInitialData(numSets int, clock clockpb.HybridLogicalClock) *persistencepb.VersioningData { + sets := make([]*persistencepb.CompatibleVersionSet, numSets) for i := 0; i < numSets; i++ { - sets[i] = mkNewSet(fmt.Sprintf("%v", i)) + sets[i] = mkNewSet(fmt.Sprintf("%v", i), clock) } return &persistencepb.VersioningData{ - VersionSets: sets, + VersionSets: sets, + DefaultUpdateTimestamp: &clock, + } +} + +func mkUserData(numSets int) *persistencepb.TaskQueueUserData { + clock := zeroHLC(1) + return &persistencepb.TaskQueueUserData{ + Clock: &clock, + VersioningData: mkInitialData(numSets, clock), } } @@ -85,215 +97,422 @@ func mkPromoteInSet(id string) *workflowservice.UpdateWorkerBuildIdCompatibility } } +func assertClockGreater(t *testing.T, clock1 clockpb.HybridLogicalClock, clock2 clockpb.HybridLogicalClock) { + if clock1.Version == clock2.Version { + assert.GreaterOrEqual(t, clock1.WallClock, clock2.WallClock) + } else { + assert.Equal(t, clock1.WallClock, clock2.WallClock) + } + assert.Equal(t, clock1.ClusterId, clock2.ClusterId) +} + func TestNewDefaultUpdate(t *testing.T) { - data := mkInitialData(2) + clock := zeroHLC(1) + initialData := mkInitialData(2, clock) req := mkNewDefReq("2") - err := UpdateVersionSets(data, req, 0) + nextClock, updatedData, err := UpdateVersionSets(clock, initialData, req, 0, 0) assert.NoError(t, err) + assertClockGreater(t, nextClock, clock) + assert.Equal(t, mkInitialData(2, clock), initialData) + + expected := &persistencepb.VersioningData{ + DefaultUpdateTimestamp: &nextClock, + VersionSets: []*persistencepb.CompatibleVersionSet{ + { + SetIds: []string{"0"}, + BuildIds: []*persistencepb.BuildID{{Id: "0", State: persistencepb.STATE_ACTIVE, StateUpdateTimestamp: &clock}}, + DefaultUpdateTimestamp: &clock, + }, + { + SetIds: []string{"1"}, + BuildIds: []*persistencepb.BuildID{{Id: "1", State: persistencepb.STATE_ACTIVE, StateUpdateTimestamp: &clock}}, + DefaultUpdateTimestamp: &clock, + }, + { + SetIds: []string{"2"}, + BuildIds: []*persistencepb.BuildID{{Id: "2", State: persistencepb.STATE_ACTIVE, StateUpdateTimestamp: &nextClock}}, + DefaultUpdateTimestamp: &nextClock, + }, + }, + } + assert.Equal(t, expected, updatedData) - curd := data.VersionSets[len(data.VersionSets)-1] - assert.Equal(t, "2", curd.BuildIds[0]) - assert.Equal(t, "1", data.VersionSets[1].BuildIds[0]) - assert.Equal(t, "0", data.VersionSets[0].BuildIds[0]) - - asResp := ToBuildIdOrderingResponse(data, 0) + asResp := ToBuildIdOrderingResponse(updatedData, 0) assert.Equal(t, "2", asResp.MajorVersionSets[2].BuildIds[0]) } -func TestNewDefaultGraphUpdateOfEmptyGraph(t *testing.T) { - data := &persistencepb.VersioningData{} +func TestNewDefaultSetUpdateOfEmptyData(t *testing.T) { + clock := zeroHLC(1) + initialData := mkInitialData(0, clock) req := mkNewDefReq("1") - err := UpdateVersionSets(data, req, 0) + nextClock, updatedData, err := UpdateVersionSets(clock, initialData, req, 0, 0) assert.NoError(t, err) - - curd := data.VersionSets[len(data.VersionSets)-1] - assert.Equal(t, "1", curd.BuildIds[0]) - assert.Equal(t, 1, len(data.VersionSets)) + assertClockGreater(t, nextClock, clock) + assert.Equal(t, mkInitialData(0, clock), initialData) + + expected := &persistencepb.VersioningData{ + DefaultUpdateTimestamp: &nextClock, + VersionSets: []*persistencepb.CompatibleVersionSet{ + { + SetIds: []string{"1"}, + BuildIds: []*persistencepb.BuildID{{Id: "1", State: persistencepb.STATE_ACTIVE, StateUpdateTimestamp: &nextClock}}, + DefaultUpdateTimestamp: &nextClock, + }, + }, + } + assert.Equal(t, expected, updatedData) } -func TestNewDefaultGraphUpdateCompatWithCurDefault(t *testing.T) { - data := mkInitialData(2) +func TestNewDefaultSetUpdateCompatWithCurDefault(t *testing.T) { + clock := zeroHLC(1) + initialData := mkInitialData(2, clock) req := mkNewCompatReq("1.1", "1", true) - err := UpdateVersionSets(data, req, 0) + nextClock, updatedData, err := UpdateVersionSets(clock, initialData, req, 0, 0) assert.NoError(t, err) - - curd := data.VersionSets[len(data.VersionSets)-1] - assert.Equal(t, "1.1", curd.BuildIds[1]) - assert.Equal(t, "1", curd.BuildIds[0]) - assert.Equal(t, "0", data.VersionSets[0].BuildIds[0]) + assertClockGreater(t, nextClock, clock) + assert.Equal(t, mkInitialData(2, clock), initialData) + + expected := &persistencepb.VersioningData{ + DefaultUpdateTimestamp: &nextClock, + VersionSets: []*persistencepb.CompatibleVersionSet{ + { + SetIds: []string{"0"}, + BuildIds: []*persistencepb.BuildID{{Id: "0", State: persistencepb.STATE_ACTIVE, StateUpdateTimestamp: &clock}}, + DefaultUpdateTimestamp: &clock, + }, + { + SetIds: []string{"1"}, + BuildIds: []*persistencepb.BuildID{ + {Id: "1", State: persistencepb.STATE_ACTIVE, StateUpdateTimestamp: &clock}, + {Id: "1.1", State: persistencepb.STATE_ACTIVE, StateUpdateTimestamp: &nextClock}, + }, + DefaultUpdateTimestamp: &nextClock, + }, + }, + } + assert.Equal(t, expected, updatedData) } -func TestNewDefaultGraphUpdateCompatWithNonDefaultSet(t *testing.T) { - data := mkInitialData(2) +func TestNewDefaultSetUpdateCompatWithNonDefaultSet(t *testing.T) { + clock := zeroHLC(1) + initialData := mkInitialData(2, clock) req := mkNewCompatReq("0.1", "0", true) - err := UpdateVersionSets(data, req, 0) + nextClock, updatedData, err := UpdateVersionSets(clock, initialData, req, 0, 0) assert.NoError(t, err) - - curd := data.VersionSets[len(data.VersionSets)-1] - assert.Equal(t, "0.1", curd.BuildIds[1]) - assert.Equal(t, "0", curd.BuildIds[0]) - assert.Equal(t, "1", data.VersionSets[0].BuildIds[0]) + assertClockGreater(t, nextClock, clock) + assert.Equal(t, mkInitialData(2, clock), initialData) + + expected := &persistencepb.VersioningData{ + DefaultUpdateTimestamp: &nextClock, + VersionSets: []*persistencepb.CompatibleVersionSet{ + { + SetIds: []string{"1"}, + BuildIds: []*persistencepb.BuildID{{Id: "1", State: persistencepb.STATE_ACTIVE, StateUpdateTimestamp: &clock}}, + DefaultUpdateTimestamp: &clock, + }, + { + SetIds: []string{"0"}, + BuildIds: []*persistencepb.BuildID{ + {Id: "0", State: persistencepb.STATE_ACTIVE, StateUpdateTimestamp: &clock}, + {Id: "0.1", State: persistencepb.STATE_ACTIVE, StateUpdateTimestamp: &nextClock}, + }, + DefaultUpdateTimestamp: &nextClock, + }, + }, + } + assert.Equal(t, expected, updatedData) } func TestNewCompatibleWithVerInOlderSet(t *testing.T) { - data := mkInitialData(3) + clock := zeroHLC(1) + initialData := mkInitialData(2, clock) req := mkNewCompatReq("0.1", "0", false) - err := UpdateVersionSets(data, req, 0) + nextClock, updatedData, err := UpdateVersionSets(clock, initialData, req, 0, 0) assert.NoError(t, err) + assertClockGreater(t, nextClock, clock) + assert.Equal(t, mkInitialData(2, clock), initialData) + + expected := &persistencepb.VersioningData{ + DefaultUpdateTimestamp: &clock, + VersionSets: []*persistencepb.CompatibleVersionSet{ + { + SetIds: []string{"0"}, + BuildIds: []*persistencepb.BuildID{ + {Id: "0", State: persistencepb.STATE_ACTIVE, StateUpdateTimestamp: &clock}, + {Id: "0.1", State: persistencepb.STATE_ACTIVE, StateUpdateTimestamp: &nextClock}, + }, + DefaultUpdateTimestamp: &nextClock, + }, + { + SetIds: []string{"1"}, + BuildIds: []*persistencepb.BuildID{{Id: "1", State: persistencepb.STATE_ACTIVE, StateUpdateTimestamp: &clock}}, + DefaultUpdateTimestamp: &clock, + }, + }, + } - curd := data.VersionSets[len(data.VersionSets)-1] - assert.Equal(t, "2", curd.BuildIds[0]) - assert.Equal(t, "0.1", data.VersionSets[0].BuildIds[1]) - assert.Equal(t, "0", data.VersionSets[0].BuildIds[0]) - - asResp := ToBuildIdOrderingResponse(data, 0) + assert.Equal(t, expected, updatedData) + asResp := ToBuildIdOrderingResponse(updatedData, 0) assert.Equal(t, "0.1", asResp.MajorVersionSets[0].BuildIds[1]) } -func TestNewCompatibleWithNonDefaultGraphUpdate(t *testing.T) { - data := mkInitialData(2) +func TestNewCompatibleWithNonDefaultSetUpdate(t *testing.T) { + clock0 := zeroHLC(1) + data := mkInitialData(2, clock0) req := mkNewCompatReq("0.1", "0", false) - err := UpdateVersionSets(data, req, 0) + clock1, data, err := UpdateVersionSets(clock0, data, req, 0, 0) assert.NoError(t, err) req = mkNewCompatReq("0.2", "0.1", false) - err = UpdateVersionSets(data, req, 0) + clock2, data, err := UpdateVersionSets(clock1, data, req, 0, 0) assert.NoError(t, err) - curd := data.VersionSets[len(data.VersionSets)-1] - assert.Equal(t, "1", curd.BuildIds[0]) - assert.Equal(t, "0", data.VersionSets[0].BuildIds[0]) - assert.Equal(t, "0.1", data.VersionSets[0].BuildIds[1]) - assert.Equal(t, "0.2", data.VersionSets[0].BuildIds[2]) + expected := &persistencepb.VersioningData{ + DefaultUpdateTimestamp: &clock0, + VersionSets: []*persistencepb.CompatibleVersionSet{ + { + SetIds: []string{"0"}, + BuildIds: []*persistencepb.BuildID{ + {Id: "0", State: persistencepb.STATE_ACTIVE, StateUpdateTimestamp: &clock0}, + {Id: "0.1", State: persistencepb.STATE_ACTIVE, StateUpdateTimestamp: &clock1}, + {Id: "0.2", State: persistencepb.STATE_ACTIVE, StateUpdateTimestamp: &clock2}, + }, + DefaultUpdateTimestamp: &clock2, + }, + { + SetIds: []string{"1"}, + BuildIds: []*persistencepb.BuildID{{Id: "1", State: persistencepb.STATE_ACTIVE, StateUpdateTimestamp: &clock0}}, + DefaultUpdateTimestamp: &clock0, + }, + }, + } + assert.Equal(t, expected, data) // Ensure setting a compatible version which targets a non-leaf compat version ends up without a branch req = mkNewCompatReq("0.3", "0.1", false) - err = UpdateVersionSets(data, req, 0) + clock3, data, err := UpdateVersionSets(clock2, data, req, 0, 0) assert.NoError(t, err) - assert.Equal(t, "1", curd.BuildIds[0]) - assert.Equal(t, "0", data.VersionSets[0].BuildIds[0]) - assert.Equal(t, "0.1", data.VersionSets[0].BuildIds[1]) - assert.Equal(t, "0.2", data.VersionSets[0].BuildIds[2]) - assert.Equal(t, "0.3", data.VersionSets[0].BuildIds[3]) + expected = &persistencepb.VersioningData{ + DefaultUpdateTimestamp: &clock0, + VersionSets: []*persistencepb.CompatibleVersionSet{ + { + SetIds: []string{"0"}, + BuildIds: []*persistencepb.BuildID{ + {Id: "0", State: persistencepb.STATE_ACTIVE, StateUpdateTimestamp: &clock0}, + {Id: "0.1", State: persistencepb.STATE_ACTIVE, StateUpdateTimestamp: &clock1}, + {Id: "0.2", State: persistencepb.STATE_ACTIVE, StateUpdateTimestamp: &clock2}, + {Id: "0.3", State: persistencepb.STATE_ACTIVE, StateUpdateTimestamp: &clock3}, + }, + DefaultUpdateTimestamp: &clock3, + }, + { + SetIds: []string{"1"}, + BuildIds: []*persistencepb.BuildID{{Id: "1", State: persistencepb.STATE_ACTIVE, StateUpdateTimestamp: &clock0}}, + DefaultUpdateTimestamp: &clock0, + }, + }, + } + + assert.Equal(t, expected, data) } func TestCompatibleTargetsNotFound(t *testing.T) { - data := mkInitialData(1) + clock := zeroHLC(1) + data := mkInitialData(1, clock) req := mkNewCompatReq("1.1", "1", false) - err := UpdateVersionSets(data, req, 0) + _, _, err := UpdateVersionSets(clock, data, req, 0, 0) assert.Error(t, err) assert.IsType(t, &serviceerror.NotFound{}, err) } func TestMakeExistingSetDefault(t *testing.T) { - data := mkInitialData(4) - - req := mkExistingDefault("2") - err := UpdateVersionSets(data, req, 0) + clock0 := zeroHLC(1) + data := mkInitialData(3, clock0) + req := mkExistingDefault("1") + clock1, data, err := UpdateVersionSets(clock0, data, req, 0, 0) assert.NoError(t, err) - assert.Equal(t, "0", data.VersionSets[0].BuildIds[0]) - assert.Equal(t, "1", data.VersionSets[1].BuildIds[0]) - assert.Equal(t, "3", data.VersionSets[2].BuildIds[0]) - assert.Equal(t, "2", data.VersionSets[3].BuildIds[0]) + expected := &persistencepb.VersioningData{ + DefaultUpdateTimestamp: &clock1, + VersionSets: []*persistencepb.CompatibleVersionSet{ + { + SetIds: []string{"0"}, + BuildIds: []*persistencepb.BuildID{ + {Id: "0", State: persistencepb.STATE_ACTIVE, StateUpdateTimestamp: &clock0}, + }, + DefaultUpdateTimestamp: &clock0, + }, + { + SetIds: []string{"2"}, + BuildIds: []*persistencepb.BuildID{{Id: "2", State: persistencepb.STATE_ACTIVE, StateUpdateTimestamp: &clock0}}, + DefaultUpdateTimestamp: &clock0, + }, + { + SetIds: []string{"1"}, + BuildIds: []*persistencepb.BuildID{{Id: "1", State: persistencepb.STATE_ACTIVE, StateUpdateTimestamp: &clock0}}, + DefaultUpdateTimestamp: &clock0, + }, + }, + } + + assert.Equal(t, expected, data) // Add a compatible version to a set and then make that set the default via the compatible version - req = mkNewCompatReq("1.1", "1", true) + req = mkNewCompatReq("0.1", "0", true) - err = UpdateVersionSets(data, req, 0) + clock2, data, err := UpdateVersionSets(clock1, data, req, 0, 0) assert.NoError(t, err) - assert.Equal(t, "0", data.VersionSets[0].BuildIds[0]) - assert.Equal(t, "3", data.VersionSets[1].BuildIds[0]) - assert.Equal(t, "2", data.VersionSets[2].BuildIds[0]) - assert.Equal(t, "1", data.VersionSets[3].BuildIds[0]) + + expected = &persistencepb.VersioningData{ + DefaultUpdateTimestamp: &clock2, + VersionSets: []*persistencepb.CompatibleVersionSet{ + { + SetIds: []string{"2"}, + BuildIds: []*persistencepb.BuildID{{Id: "2", State: persistencepb.STATE_ACTIVE, StateUpdateTimestamp: &clock0}}, + DefaultUpdateTimestamp: &clock0, + }, + { + SetIds: []string{"1"}, + BuildIds: []*persistencepb.BuildID{{Id: "1", State: persistencepb.STATE_ACTIVE, StateUpdateTimestamp: &clock0}}, + DefaultUpdateTimestamp: &clock0, + }, + { + SetIds: []string{"0"}, + BuildIds: []*persistencepb.BuildID{ + {Id: "0", State: persistencepb.STATE_ACTIVE, StateUpdateTimestamp: &clock0}, + {Id: "0.1", State: persistencepb.STATE_ACTIVE, StateUpdateTimestamp: &clock2}, + }, + DefaultUpdateTimestamp: &clock2, + }, + }, + } + assert.Equal(t, expected, data) } func TestSayVersionIsCompatWithDifferentSetThanItsAlreadyCompatWithNotAllowed(t *testing.T) { - data := mkInitialData(3) + clock := zeroHLC(1) + data := mkInitialData(3, clock) req := mkNewCompatReq("0.1", "0", false) - err := UpdateVersionSets(data, req, 0) + _, data, err := UpdateVersionSets(clock, data, req, 0, 0) assert.NoError(t, err) req = mkNewCompatReq("0.1", "1", false) - err = UpdateVersionSets(data, req, 0) + _, _, err = UpdateVersionSets(clock, data, req, 0, 0) assert.Error(t, err) assert.IsType(t, &serviceerror.InvalidArgument{}, err) } -func TestLimitsMaxSize(t *testing.T) { - data := &persistencepb.VersioningData{} - maxSize := 10 +func TestLimitsMaxSets(t *testing.T) { + clock := zeroHLC(1) + maxSets := 10 + data := mkInitialData(maxSets, clock) - for i := 0; i < 20; i++ { - id := fmt.Sprintf("%d", i) - req := mkNewDefReq(id) - err := UpdateVersionSets(data, req, maxSize) - assert.NoError(t, err) - } + req := mkNewDefReq("10") + _, _, err := UpdateVersionSets(clock, data, req, maxSets, 0) + assert.Error(t, err) + assert.IsType(t, &serviceerror.FailedPrecondition{}, err) +} - for i := 0; i < len(data.VersionSets); i++ { - assert.Equal(t, fmt.Sprintf("%d", i+10), data.VersionSets[i].BuildIds[0]) - } +func TestLimitsMaxBuildIDs(t *testing.T) { + clock := zeroHLC(1) + maxBuildIDs := 10 + data := mkInitialData(maxBuildIDs, clock) + + req := mkNewDefReq("10") + _, _, err := UpdateVersionSets(clock, data, req, 0, maxBuildIDs) + assert.Error(t, err) + assert.IsType(t, &serviceerror.FailedPrecondition{}, err) } func TestPromoteWithinVersion(t *testing.T) { - data := mkInitialData(3) - - for i := 1; i <= 5; i++ { - req := mkNewCompatReq(fmt.Sprintf("0.%d", i), "0", false) - err := UpdateVersionSets(data, req, 0) - assert.NoError(t, err) - } + clock0 := zeroHLC(1) + data := mkInitialData(2, clock0) - req := mkPromoteInSet("0.1") - err := UpdateVersionSets(data, req, 0) + req := mkNewCompatReq("0.1", "0", false) + clock1, data, err := UpdateVersionSets(clock0, data, req, 0, 0) + assert.NoError(t, err) + req = mkNewCompatReq("0.2", "0", false) + clock2, data, err := UpdateVersionSets(clock1, data, req, 0, 0) + assert.NoError(t, err) + req = mkPromoteInSet("0.1") + clock3, data, err := UpdateVersionSets(clock2, data, req, 0, 0) assert.NoError(t, err) - curd := data.VersionSets[0].BuildIds[len(data.VersionSets[0].BuildIds)-1] - assert.Equal(t, "0.1", curd) + expected := &persistencepb.VersioningData{ + DefaultUpdateTimestamp: &clock0, + VersionSets: []*persistencepb.CompatibleVersionSet{ + { + SetIds: []string{"0"}, + BuildIds: []*persistencepb.BuildID{ + {Id: "0", State: persistencepb.STATE_ACTIVE, StateUpdateTimestamp: &clock0}, + {Id: "0.2", State: persistencepb.STATE_ACTIVE, StateUpdateTimestamp: &clock2}, + {Id: "0.1", State: persistencepb.STATE_ACTIVE, StateUpdateTimestamp: &clock1}, + }, + DefaultUpdateTimestamp: &clock3, + }, + { + SetIds: []string{"1"}, + BuildIds: []*persistencepb.BuildID{{Id: "1", State: persistencepb.STATE_ACTIVE, StateUpdateTimestamp: &clock0}}, + DefaultUpdateTimestamp: &clock0, + }, + }, + } + assert.Equal(t, expected, data) } func TestAddAlreadyExtantVersionAsDefaultErrors(t *testing.T) { - data := mkInitialData(3) + clock := zeroHLC(1) + data := mkInitialData(3, clock) req := mkNewDefReq("0") - err := UpdateVersionSets(data, req, 0) + _, _, err := UpdateVersionSets(clock, data, req, 0, 0) assert.Error(t, err) assert.IsType(t, &serviceerror.InvalidArgument{}, err) } func TestAddAlreadyExtantVersionToAnotherSetErrors(t *testing.T) { - data := mkInitialData(3) + clock := zeroHLC(1) + data := mkInitialData(3, clock) req := mkNewCompatReq("0", "1", false) - err := UpdateVersionSets(data, req, 0) + _, _, err := UpdateVersionSets(clock, data, req, 0, 0) assert.Error(t, err) assert.IsType(t, &serviceerror.InvalidArgument{}, err) } func TestMakeSetDefaultTargetingNonexistentVersionErrors(t *testing.T) { - data := mkInitialData(3) + clock := zeroHLC(1) + data := mkInitialData(3, clock) req := mkExistingDefault("crab boi") - err := UpdateVersionSets(data, req, 0) + _, _, err := UpdateVersionSets(clock, data, req, 0, 0) assert.Error(t, err) assert.IsType(t, &serviceerror.NotFound{}, err) } func TestPromoteWithinSetTargetingNonexistentVersionErrors(t *testing.T) { - data := mkInitialData(3) + clock := zeroHLC(1) + data := mkInitialData(3, clock) req := mkPromoteInSet("i'd rather be writing rust ;)") - err := UpdateVersionSets(data, req, 0) + _, _, err := UpdateVersionSets(clock, data, req, 0, 0) assert.Error(t, err) assert.IsType(t, &serviceerror.NotFound{}, err) } + +func TestToBuildIdOrderingResponseTrimsResponse(t *testing.T) { + clock := zeroHLC(1) + data := mkInitialData(3, clock) + actual := ToBuildIdOrderingResponse(data, 2) + expected := []*taskqueuepb.CompatibleVersionSet{{BuildIds: []string{"1"}}, {BuildIds: []string{"2"}}} + assert.Equal(t, expected, actual.MajorVersionSets) +} diff --git a/tests/flag.go b/tests/flag.go index d720e335938..5203b10d400 100644 --- a/tests/flag.go +++ b/tests/flag.go @@ -38,7 +38,7 @@ var TestFlags struct { func init() { flag.StringVar(&TestFlags.FrontendAddr, "frontendAddress", "", "host:port for temporal frontend service") flag.StringVar(&TestFlags.PersistenceType, "persistenceType", "nosql", "type of persistence - [nosql or sql]") - flag.StringVar(&TestFlags.PersistenceDriver, "persistenceDriver", "cassandra", "driver of nosql / sql- [cassandra, mysql, postgresql]") + flag.StringVar(&TestFlags.PersistenceDriver, "persistenceDriver", "cassandra", "driver of nosql / sql- [cassandra, mysql, postgresql, sqlite]") flag.StringVar(&TestFlags.TestClusterConfigFile, "TestClusterConfigFile", "", "test cluster config file location") flag.Float64Var(&TestFlags.PersistenceFaultInjectionRate, "PersistenceFaultInjectionRate", 0, "rate of persistence error injection. value: [0..1]. 0 = no injection") }