01896606-c2a7-4c89-817d-e6d1dc3a5a18

Committed 17 Jul 2023 10:44PM UTC coverage: 57.021% (-0.2%) from 57.249%

Build # 01896606-c2a7-4c89-817d-e6d1dc3a5a18

Build Type

push

buildkite

Committed by

web-flow

Commit Message

Merge master (#5351)

* Add Opensearch2 client with bulk API shared between clients (#5241)

* Allow to configure HTTP settings using template (#5329)

* CDNC-3181 Cleanup the unused watchdog code (#5096)

* Removed the Watchdog code and it's service calls

* Removed watchdog occurences and dependencies

---------

Co-authored-by: David Porter <david.porter@uber.com>

* Upgrade yarpc to v1.70.3 (#5341)

* upgrade mysql (#5345)

* upgrade mysql

* upgrade mysql version into 8.0 in docker files

* update all 5.7 to 8.0

* [dynamic config] add Filters method to dynamic config Key (#5346)

What changed?

Add Filters method to Key interface
Add implementations on most keys by parsing the comments on keys (assuming they are correct)
Why?

This is needed to know what dynamic config is domain specific. And this could possible simplify the collection struct by consolidating all GetPropertyFilterBy** methods.

How did you test it?

Potential risks

no risk since the method will be read only in non-critical path

Release notes

Documentation Changes

---------

Co-authored-by: Mantas Šidlauskas <sidlauskas.mantas@gmail.com>
Co-authored-by: agautam478 <72432016+agautam478@users.noreply.github.com>
Co-authored-by: David Porter <david.porter@uber.com>
Co-authored-by: Mantas Šidlauskas <mantass@netapp.com>
Co-authored-by: bowen xiao <xbowen@uber.com>

Run Details

799 of 799 new or added lines in 17 files covered. (100.0%)

87154 of 152845 relevant lines covered (57.02%)

2484.19 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

65.41

/common/persistence/serialization/parser.go

// The MIT License (MIT)
//
// Copyright (c) 2017-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.

package serialization

import (
        "fmt"

        "github.com/uber/cadence/common"
        "github.com/uber/cadence/common/persistence"
)

type (
        parser struct {
                encoder  encoder
                decoders map[common.EncodingType]decoder
        }
)

// NewParser constructs a new parser using encoder as specified by encodingType and using decoders specified by decodingTypes
func NewParser(encodingType common.EncodingType, decodingTypes ...common.EncodingType) (Parser, error) {
        encoder, err := getEncoder(encodingType)
        if err != nil {
                return nil, err
        }
        decoders := make(map[common.EncodingType]decoder)
        for _, dt := range decodingTypes {
                decoder, err := getDecoder(dt)
                if err != nil {
                        return nil, err
                }
                decoders[dt] = decoder
        }
        return &parser{
                encoder:  encoder,
                decoders: decoders,
        }, nil
}

func (p *parser) ShardInfoToBlob(info *ShardInfo) (persistence.DataBlob, error) {
        db := persistence.DataBlob{}
        data, err := p.encoder.shardInfoToBlob(info)
        if err != nil {
                return db, err
        }
        db.Data = data
        db.Encoding = p.encoder.encodingType()
        return db, nil
}

func (p *parser) DomainInfoToBlob(info *DomainInfo) (persistence.DataBlob, error) {
        db := persistence.DataBlob{}
        data, err := p.encoder.domainInfoToBlob(info)
        if err != nil {
                return db, err
        }
        db.Data = data
        db.Encoding = p.encoder.encodingType()
        return db, nil
}

func (p *parser) HistoryTreeInfoToBlob(info *HistoryTreeInfo) (persistence.DataBlob, error) {
        db := persistence.DataBlob{}
        data, err := p.encoder.historyTreeInfoToBlob(info)
        if err != nil {
                return db, err
        }
        db.Data = data
        db.Encoding = p.encoder.encodingType()
        return db, nil
}

func (p *parser) WorkflowExecutionInfoToBlob(info *WorkflowExecutionInfo) (persistence.DataBlob, error) {
        db := persistence.DataBlob{}
        data, err := p.encoder.workflowExecutionInfoToBlob(info)
        if err != nil {
                return db, err
        }
        db.Data = data
        db.Encoding = p.encoder.encodingType()
        return db, nil
}

func (p *parser) ActivityInfoToBlob(info *ActivityInfo) (persistence.DataBlob, error) {
        db := persistence.DataBlob{}
        data, err := p.encoder.activityInfoToBlob(info)
        if err != nil {
                return db, err
        }
        db.Data = data
        db.Encoding = p.encoder.encodingType()
        return db, nil
}

func (p *parser) ChildExecutionInfoToBlob(info *ChildExecutionInfo) (persistence.DataBlob, error) {
        db := persistence.DataBlob{}
        data, err := p.encoder.childExecutionInfoToBlob(info)
        if err != nil {
                return db, err
        }
        db.Data = data
        db.Encoding = p.encoder.encodingType()
        return db, nil
}

func (p *parser) SignalInfoToBlob(info *SignalInfo) (persistence.DataBlob, error) {
        db := persistence.DataBlob{}
        data, err := p.encoder.signalInfoToBlob(info)
        if err != nil {
                return db, err
        }
        db.Data = data
        db.Encoding = p.encoder.encodingType()
        return db, nil
}

func (p *parser) RequestCancelInfoToBlob(info *RequestCancelInfo) (persistence.DataBlob, error) {
        db := persistence.DataBlob{}
        data, err := p.encoder.requestCancelInfoToBlob(info)
        if err != nil {
                return db, err
        }
        db.Data = data
        db.Encoding = p.encoder.encodingType()
        return db, nil
}

func (p *parser) TimerInfoToBlob(info *TimerInfo) (persistence.DataBlob, error) {
        db := persistence.DataBlob{}
        data, err := p.encoder.timerInfoToBlob(info)
        if err != nil {
                return db, err
        }
        db.Data = data
        db.Encoding = p.encoder.encodingType()
        return db, nil
}

func (p *parser) TaskInfoToBlob(info *TaskInfo) (persistence.DataBlob, error) {
        db := persistence.DataBlob{}
        data, err := p.encoder.taskInfoToBlob(info)
        if err != nil {
                return db, err
        }
        db.Data = data
        db.Encoding = p.encoder.encodingType()
        return db, nil
}

func (p *parser) TaskListInfoToBlob(info *TaskListInfo) (persistence.DataBlob, error) {
        db := persistence.DataBlob{}
        data, err := p.encoder.taskListInfoToBlob(info)
        if err != nil {
                return db, err
        }
        db.Data = data
        db.Encoding = p.encoder.encodingType()
        return db, nil
}

func (p *parser) TransferTaskInfoToBlob(info *TransferTaskInfo) (persistence.DataBlob, error) {
        db := persistence.DataBlob{}
        data, err := p.encoder.transferTaskInfoToBlob(info)
        if err != nil {
                return db, err
        }
        db.Data = data
        db.Encoding = p.encoder.encodingType()
        return db, nil
}

func (p *parser) CrossClusterTaskInfoToBlob(info *CrossClusterTaskInfo) (persistence.DataBlob, error) {
        db := persistence.DataBlob{}
        data, err := p.encoder.crossClusterTaskInfoToBlob(info)
        if err != nil {
                return db, err
        }
        db.Data = data
        db.Encoding = p.encoder.encodingType()
        return db, nil
}

func (p *parser) TimerTaskInfoToBlob(info *TimerTaskInfo) (persistence.DataBlob, error) {
        db := persistence.DataBlob{}
        data, err := p.encoder.timerTaskInfoToBlob(info)
        if err != nil {
                return db, err
        }
        db.Data = data
        db.Encoding = p.encoder.encodingType()
        return db, nil
}

func (p *parser) ReplicationTaskInfoToBlob(info *ReplicationTaskInfo) (persistence.DataBlob, error) {
        db := persistence.DataBlob{}
        data, err := p.encoder.replicationTaskInfoToBlob(info)
        if err != nil {
                return db, err
        }
        db.Data = data
        db.Encoding = p.encoder.encodingType()
        return db, nil
}

func (p *parser) ShardInfoFromBlob(data []byte, encoding string) (*ShardInfo, error) {
        decoder, err := p.getCachedDecoder(common.EncodingType(encoding))
        if err != nil {
                return nil, err
        }
        return decoder.shardInfoFromBlob(data)
}

func (p *parser) DomainInfoFromBlob(data []byte, encoding string) (*DomainInfo, error) {
        decoder, err := p.getCachedDecoder(common.EncodingType(encoding))
        if err != nil {
                return nil, err
        }
        return decoder.domainInfoFromBlob(data)
}

func (p *parser) HistoryTreeInfoFromBlob(data []byte, encoding string) (*HistoryTreeInfo, error) {
        decoder, err := p.getCachedDecoder(common.EncodingType(encoding))
        if err != nil {
                return nil, err
        }
        return decoder.historyTreeInfoFromBlob(data)
}

func (p *parser) WorkflowExecutionInfoFromBlob(data []byte, encoding string) (*WorkflowExecutionInfo, error) {
        decoder, err := p.getCachedDecoder(common.EncodingType(encoding))
        if err != nil {
                return nil, err
        }
        return decoder.workflowExecutionInfoFromBlob(data)
}

func (p *parser) ActivityInfoFromBlob(data []byte, encoding string) (*ActivityInfo, error) {
        decoder, err := p.getCachedDecoder(common.EncodingType(encoding))
        if err != nil {
                return nil, err
        }
        return decoder.activityInfoFromBlob(data)
}

func (p *parser) ChildExecutionInfoFromBlob(data []byte, encoding string) (*ChildExecutionInfo, error) {
        decoder, err := p.getCachedDecoder(common.EncodingType(encoding))
        if err != nil {
                return nil, err
        }
        return decoder.childExecutionInfoFromBlob(data)
}

func (p *parser) SignalInfoFromBlob(data []byte, encoding string) (*SignalInfo, error) {
        decoder, err := p.getCachedDecoder(common.EncodingType(encoding))
        if err != nil {
                return nil, err
        }
        return decoder.signalInfoFromBlob(data)
}

func (p *parser) RequestCancelInfoFromBlob(data []byte, encoding string) (*RequestCancelInfo, error) {
        decoder, err := p.getCachedDecoder(common.EncodingType(encoding))
        if err != nil {
                return nil, err
        }
        return decoder.requestCancelInfoFromBlob(data)
}

func (p *parser) TimerInfoFromBlob(data []byte, encoding string) (*TimerInfo, error) {
        decoder, err := p.getCachedDecoder(common.EncodingType(encoding))
        if err != nil {
                return nil, err
        }
        return decoder.timerInfoFromBlob(data)
}

func (p *parser) TaskInfoFromBlob(data []byte, encoding string) (*TaskInfo, error) {
        decoder, err := p.getCachedDecoder(common.EncodingType(encoding))
        if err != nil {
                return nil, err
        }
        return decoder.taskInfoFromBlob(data)
}

func (p *parser) TaskListInfoFromBlob(data []byte, encoding string) (*TaskListInfo, error) {
        decoder, err := p.getCachedDecoder(common.EncodingType(encoding))
        if err != nil {
                return nil, err
        }
        return decoder.taskListInfoFromBlob(data)
}

func (p *parser) TransferTaskInfoFromBlob(data []byte, encoding string) (*TransferTaskInfo, error) {
        decoder, err := p.getCachedDecoder(common.EncodingType(encoding))
        if err != nil {
                return nil, err
        }
        return decoder.transferTaskInfoFromBlob(data)
}

func (p *parser) CrossClusterTaskInfoFromBlob(data []byte, encoding string) (*CrossClusterTaskInfo, error) {
        decoder, err := p.getCachedDecoder(common.EncodingType(encoding))
        if err != nil {
                return nil, err
        }
        return decoder.crossClusterTaskInfoFromBlob(data)
}

func (p *parser) TimerTaskInfoFromBlob(data []byte, encoding string) (*TimerTaskInfo, error) {
        decoder, err := p.getCachedDecoder(common.EncodingType(encoding))
        if err != nil {
                return nil, err
        }
        return decoder.timerTaskInfoFromBlob(data)
}

func (p *parser) ReplicationTaskInfoFromBlob(data []byte, encoding string) (*ReplicationTaskInfo, error) {
        decoder, err := p.getCachedDecoder(common.EncodingType(encoding))
        if err != nil {
                return nil, err
        }
        return decoder.replicationTaskInfoFromBlob(data)
}

func (p *parser) getCachedDecoder(encoding common.EncodingType) (decoder, error) {
        decoder, ok := p.decoders[encoding]
        if !ok {
                return nil, unsupportedEncodingError(encoding)
        }
        return decoder, nil
}

func getDecoder(encoding common.EncodingType) (decoder, error) {
        switch encoding {
        case common.EncodingTypeThriftRW:
                return newThriftDecoder(), nil
        case common.EncodingTypeProto:
                return newProtoDecoder(), nil
        default:
                return nil, unsupportedEncodingError(encoding)
        }
}

func getEncoder(encoding common.EncodingType) (encoder, error) {
        switch encoding {
        case common.EncodingTypeThriftRW:
                return newThriftEncoder(), nil
        case common.EncodingTypeProto:
                return newProtoEncoder(), nil
        default:
                return nil, unsupportedEncodingError(encoding)
        }
}

func unsupportedEncodingError(encoding common.EncodingType) error {
        return fmt.Errorf("invalid encoding type: %v", encoding)
}

1	// The MIT License (MIT)
2	//
3	// Copyright (c) 2017-2020 Uber Technologies Inc.
4	//
5	// Permission is hereby granted, free of charge, to any person obtaining a copy
6	// of this software and associated documentation files (the "Software"), to deal
7	// in the Software without restriction, including without limitation the rights
8	// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
9	// copies of the Software, and to permit persons to whom the Software is
10	// furnished to do so, subject to the following conditions:
11	//
12	// The above copyright notice and this permission notice shall be included in all
13	// copies or substantial portions of the Software.
14	//
15	// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16	// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17	// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18	// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19	// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20	// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21	// SOFTWARE.
22
23	package serialization
24
25	import (
26	"fmt"
27
28	"github.com/uber/cadence/common"
29	"github.com/uber/cadence/common/persistence"
30	)
31
32	type (
33	parser struct {
34	encoder encoder
35	decoders map[common.EncodingType]decoder
36	}
37	)
38
39	// NewParser constructs a new parser using encoder as specified by encodingType and using decoders specified by decodingTypes
40	func NewParser(encodingType common.EncodingType, decodingTypes ...common.EncodingType) (Parser, error) {	67✔
41	encoder, err := getEncoder(encodingType)	67✔
42	if err != nil {	67✔
43	return nil, err	×
44	}	×
45	decoders := make(map[common.EncodingType]decoder)	67✔
46	for _, dt := range decodingTypes {	134✔
47	decoder, err := getDecoder(dt)	67✔
48	if err != nil {	67✔
49	return nil, err	×
50	}	×
51	decoders[dt] = decoder	67✔
52	}
53	return &parser{	67✔
54	encoder: encoder,	67✔
55	decoders: decoders,	67✔
56	}, nil	67✔
57	}
58
59	func (p parser) ShardInfoToBlob(info ShardInfo) (persistence.DataBlob, error) {	114✔
60	db := persistence.DataBlob{}	114✔
61	data, err := p.encoder.shardInfoToBlob(info)	114✔
62	if err != nil {	114✔
63	return db, err	×
64	}	×
65	db.Data = data	114✔
66	db.Encoding = p.encoder.encodingType()	114✔
67	return db, nil	114✔
68	}
69
70	func (p parser) DomainInfoToBlob(info DomainInfo) (persistence.DataBlob, error) {	43✔
71	db := persistence.DataBlob{}	43✔
72	data, err := p.encoder.domainInfoToBlob(info)	43✔
73	if err != nil {	43✔
74	return db, err	×
75	}	×
76	db.Data = data	43✔
77	db.Encoding = p.encoder.encodingType()	43✔
78	return db, nil	43✔
79	}
80
81	func (p parser) HistoryTreeInfoToBlob(info HistoryTreeInfo) (persistence.DataBlob, error) {	442✔
82	db := persistence.DataBlob{}	442✔
83	data, err := p.encoder.historyTreeInfoToBlob(info)	442✔
84	if err != nil {	442✔
85	return db, err	×
86	}	×
87	db.Data = data	442✔
88	db.Encoding = p.encoder.encodingType()	442✔
89	return db, nil	442✔
90	}
91
92	func (p parser) WorkflowExecutionInfoToBlob(info WorkflowExecutionInfo) (persistence.DataBlob, error) {	3,364✔
93	db := persistence.DataBlob{}	3,364✔
94	data, err := p.encoder.workflowExecutionInfoToBlob(info)	3,364✔
95	if err != nil {	3,364✔
96	return db, err	×
97	}	×
98	db.Data = data	3,364✔
99	db.Encoding = p.encoder.encodingType()	3,364✔
100	return db, nil	3,364✔
101	}
102
103	func (p parser) ActivityInfoToBlob(info ActivityInfo) (persistence.DataBlob, error) {	850✔
104	db := persistence.DataBlob{}	850✔
105	data, err := p.encoder.activityInfoToBlob(info)	850✔
106	if err != nil {	850✔
107	return db, err	×
108	}	×
109	db.Data = data	850✔
110	db.Encoding = p.encoder.encodingType()	850✔
111	return db, nil	850✔
112	}
113
114	func (p parser) ChildExecutionInfoToBlob(info ChildExecutionInfo) (persistence.DataBlob, error) {	26✔
115	db := persistence.DataBlob{}	26✔
116	data, err := p.encoder.childExecutionInfoToBlob(info)	26✔
117	if err != nil {	26✔
118	return db, err	×
119	}	×
120	db.Data = data	26✔
121	db.Encoding = p.encoder.encodingType()	26✔
122	return db, nil	26✔
123	}
124
125	func (p parser) SignalInfoToBlob(info SignalInfo) (persistence.DataBlob, error) {	10✔
126	db := persistence.DataBlob{}	10✔
127	data, err := p.encoder.signalInfoToBlob(info)	10✔
128	if err != nil {	10✔
129	return db, err	×
130	}	×
131	db.Data = data	10✔
132	db.Encoding = p.encoder.encodingType()	10✔
133	return db, nil	10✔
134	}
135
136	func (p parser) RequestCancelInfoToBlob(info RequestCancelInfo) (persistence.DataBlob, error) {	6✔
137	db := persistence.DataBlob{}	6✔
138	data, err := p.encoder.requestCancelInfoToBlob(info)	6✔
139	if err != nil {	6✔
140	return db, err	×
141	}	×
142	db.Data = data	6✔
143	db.Encoding = p.encoder.encodingType()	6✔
144	return db, nil	6✔
145	}
146
147	func (p parser) TimerInfoToBlob(info TimerInfo) (persistence.DataBlob, error) {	22✔
148	db := persistence.DataBlob{}	22✔
149	data, err := p.encoder.timerInfoToBlob(info)	22✔
150	if err != nil {	22✔
151	return db, err	×
152	}	×
153	db.Data = data	22✔
154	db.Encoding = p.encoder.encodingType()	22✔
155	return db, nil	22✔
156	}
157
158	func (p parser) TaskInfoToBlob(info TaskInfo) (persistence.DataBlob, error) {	601✔
159	db := persistence.DataBlob{}	601✔
160	data, err := p.encoder.taskInfoToBlob(info)	601✔
161	if err != nil {	601✔
162	return db, err	×
163	}	×
164	db.Data = data	601✔
165	db.Encoding = p.encoder.encodingType()	601✔
166	return db, nil	601✔
167	}
168
169	func (p parser) TaskListInfoToBlob(info TaskListInfo) (persistence.DataBlob, error) {	5,610✔
170	db := persistence.DataBlob{}	5,610✔
171	data, err := p.encoder.taskListInfoToBlob(info)	5,610✔
172	if err != nil {	5,610✔
173	return db, err	×
174	}	×
175	db.Data = data	5,610✔
176	db.Encoding = p.encoder.encodingType()	5,610✔
177	return db, nil	5,610✔
178	}
179
180	func (p parser) TransferTaskInfoToBlob(info TransferTaskInfo) (persistence.DataBlob, error) {	1,938✔
181	db := persistence.DataBlob{}	1,938✔
182	data, err := p.encoder.transferTaskInfoToBlob(info)	1,938✔
183	if err != nil {	1,938✔
184	return db, err	×
185	}	×
186	db.Data = data	1,938✔
187	db.Encoding = p.encoder.encodingType()	1,938✔
188	return db, nil	1,938✔
189	}
190
191	func (p parser) CrossClusterTaskInfoToBlob(info CrossClusterTaskInfo) (persistence.DataBlob, error) {	×
192	db := persistence.DataBlob{}	×
193	data, err := p.encoder.crossClusterTaskInfoToBlob(info)	×
194	if err != nil {	×
195	return db, err	×
196	}	×
197	db.Data = data	×
198	db.Encoding = p.encoder.encodingType()	×
199	return db, nil	×
200	}
201
202	func (p parser) TimerTaskInfoToBlob(info TimerTaskInfo) (persistence.DataBlob, error) {	2,123✔
203	db := persistence.DataBlob{}	2,123✔
204	data, err := p.encoder.timerTaskInfoToBlob(info)	2,123✔
205	if err != nil {	2,123✔
206	return db, err	×
207	}	×
208	db.Data = data	2,123✔
209	db.Encoding = p.encoder.encodingType()	2,123✔
210	return db, nil	2,123✔
211	}
212
213	func (p parser) ReplicationTaskInfoToBlob(info ReplicationTaskInfo) (persistence.DataBlob, error) {	2✔
214	db := persistence.DataBlob{}	2✔
215	data, err := p.encoder.replicationTaskInfoToBlob(info)	2✔
216	if err != nil {	2✔
217	return db, err	×
218	}	×
219	db.Data = data	2✔
220	db.Encoding = p.encoder.encodingType()	2✔
221	return db, nil	2✔
222	}
223
224	func (p parser) ShardInfoFromBlob(data []byte, encoding string) (ShardInfo, error) {	24✔
225	decoder, err := p.getCachedDecoder(common.EncodingType(encoding))	24✔
226	if err != nil {	24✔
227	return nil, err	×
228	}	×
229	return decoder.shardInfoFromBlob(data)	24✔
230	}
231
232	func (p parser) DomainInfoFromBlob(data []byte, encoding string) (DomainInfo, error) {	3,137✔
233	decoder, err := p.getCachedDecoder(common.EncodingType(encoding))	3,137✔
234	if err != nil {	3,137✔
235	return nil, err	×
236	}	×
237	return decoder.domainInfoFromBlob(data)	3,137✔
238	}
239
240	func (p parser) HistoryTreeInfoFromBlob(data []byte, encoding string) (HistoryTreeInfo, error) {	37✔
241	decoder, err := p.getCachedDecoder(common.EncodingType(encoding))	37✔
242	if err != nil {	37✔
243	return nil, err	×
244	}	×
245	return decoder.historyTreeInfoFromBlob(data)	37✔
246	}
247
248	func (p parser) WorkflowExecutionInfoFromBlob(data []byte, encoding string) (WorkflowExecutionInfo, error) {	494✔
249	decoder, err := p.getCachedDecoder(common.EncodingType(encoding))	494✔
250	if err != nil {	494✔
251	return nil, err	×
252	}	×
253	return decoder.workflowExecutionInfoFromBlob(data)	494✔
254	}
255
256	func (p parser) ActivityInfoFromBlob(data []byte, encoding string) (ActivityInfo, error) {	78✔
257	decoder, err := p.getCachedDecoder(common.EncodingType(encoding))	78✔
258	if err != nil {	78✔
259	return nil, err	×
260	}	×
261	return decoder.activityInfoFromBlob(data)	78✔
262	}
263
264	func (p parser) ChildExecutionInfoFromBlob(data []byte, encoding string) (ChildExecutionInfo, error) {	3✔
265	decoder, err := p.getCachedDecoder(common.EncodingType(encoding))	3✔
266	if err != nil {	3✔
267	return nil, err	×
268	}	×
269	return decoder.childExecutionInfoFromBlob(data)	3✔
270	}
271
272	func (p parser) SignalInfoFromBlob(data []byte, encoding string) (SignalInfo, error) {	×
273	decoder, err := p.getCachedDecoder(common.EncodingType(encoding))	×
274	if err != nil {	×
275	return nil, err	×
276	}	×
277	return decoder.signalInfoFromBlob(data)	×
278	}
279
280	func (p parser) RequestCancelInfoFromBlob(data []byte, encoding string) (RequestCancelInfo, error) {	1✔
281	decoder, err := p.getCachedDecoder(common.EncodingType(encoding))	1✔
282	if err != nil {	1✔
283	return nil, err	×
284	}	×
285	return decoder.requestCancelInfoFromBlob(data)	1✔
286	}
287
288	func (p parser) TimerInfoFromBlob(data []byte, encoding string) (TimerInfo, error) {	1✔
289	decoder, err := p.getCachedDecoder(common.EncodingType(encoding))	1✔
290	if err != nil {	1✔
291	return nil, err	×
292	}	×
293	return decoder.timerInfoFromBlob(data)	1✔
294	}
295
296	func (p parser) TaskInfoFromBlob(data []byte, encoding string) (TaskInfo, error) {	602✔
297	decoder, err := p.getCachedDecoder(common.EncodingType(encoding))	602✔
298	if err != nil {	602✔
299	return nil, err	×
300	}	×
301	return decoder.taskInfoFromBlob(data)	602✔
302	}
303
304	func (p parser) TaskListInfoFromBlob(data []byte, encoding string) (TaskListInfo, error) {	889✔
305	decoder, err := p.getCachedDecoder(common.EncodingType(encoding))	889✔
306	if err != nil {	889✔
307	return nil, err	×
308	}	×
309	return decoder.taskListInfoFromBlob(data)	889✔
310	}
311
312	func (p parser) TransferTaskInfoFromBlob(data []byte, encoding string) (TransferTaskInfo, error) {	3,697✔
313	decoder, err := p.getCachedDecoder(common.EncodingType(encoding))	3,697✔
314	if err != nil {	3,697✔
315	return nil, err	×
316	}	×
317	return decoder.transferTaskInfoFromBlob(data)	3,697✔
318	}
319
320	func (p parser) CrossClusterTaskInfoFromBlob(data []byte, encoding string) (CrossClusterTaskInfo, error) {	×
321	decoder, err := p.getCachedDecoder(common.EncodingType(encoding))	×
322	if err != nil {	×
323	return nil, err	×
324	}	×
325	return decoder.crossClusterTaskInfoFromBlob(data)	×
326	}
327
328	func (p parser) TimerTaskInfoFromBlob(data []byte, encoding string) (TimerTaskInfo, error) {	5,732✔
329	decoder, err := p.getCachedDecoder(common.EncodingType(encoding))	5,732✔
330	if err != nil {	5,732✔
331	return nil, err	×
332	}	×
333	return decoder.timerTaskInfoFromBlob(data)	5,732✔
334	}
335
336	func (p parser) ReplicationTaskInfoFromBlob(data []byte, encoding string) (ReplicationTaskInfo, error) {	2✔
337	decoder, err := p.getCachedDecoder(common.EncodingType(encoding))	2✔
338	if err != nil {	2✔
339	return nil, err	×
340	}	×
341	return decoder.replicationTaskInfoFromBlob(data)	2✔
342	}
343
344	func (p *parser) getCachedDecoder(encoding common.EncodingType) (decoder, error) {	14,682✔
345	decoder, ok := p.decoders[encoding]	14,682✔
346	if !ok {	14,682✔
347	return nil, unsupportedEncodingError(encoding)	×
348	}	×
349	return decoder, nil	14,682✔
350	}
351
352	func getDecoder(encoding common.EncodingType) (decoder, error) {	67✔
353	switch encoding {	67✔
354	case common.EncodingTypeThriftRW:	67✔
355	return newThriftDecoder(), nil	67✔
356	case common.EncodingTypeProto:	×
357	return newProtoDecoder(), nil	×
358	default:	×
359	return nil, unsupportedEncodingError(encoding)	×
360	}
361	}
362
363	func getEncoder(encoding common.EncodingType) (encoder, error) {	67✔
364	switch encoding {	67✔
365	case common.EncodingTypeThriftRW:	67✔
366	return newThriftEncoder(), nil	67✔
367	case common.EncodingTypeProto:	×
368	return newProtoEncoder(), nil	×
369	default:	×
370	return nil, unsupportedEncodingError(encoding)	×
371	}
372	}
373
374	func unsupportedEncodingError(encoding common.EncodingType) error {	×
375	return fmt.Errorf("invalid encoding type: %v", encoding)	×
376	}	×

uber / cadence / 01896606-c2a7-4c89-817d-e6d1dc3a5a18

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous