0186ed8c-939f-4cc5-9459-fac2c80653f9

Committed 17 Mar 2023 03:30AM UTC coverage: 57.113% (-0.005%) from 57.118%

Build # 0186ed8c-939f-4cc5-9459-fac2c80653f9

Build Type

push

buildkite

Committed by GitHub

Commit Message

[history] more cautious in deciding domain state to make decisions on dropping queued tasks (#5164)

Run Details

1 of 1 new or added line in 1 file covered. (100.0%)

85268 of 149297 relevant lines covered (57.11%)

2300.93 hits per line

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

63.91

/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,357✔
93	db := persistence.DataBlob{}	3,357✔
94	data, err := p.encoder.workflowExecutionInfoToBlob(info)	3,357✔
95	if err != nil {	3,357✔
96	return db, err	×
97	}	×
98	db.Data = data	3,357✔
99	db.Encoding = p.encoder.encodingType()	3,357✔
100	return db, nil	3,357✔
101	}
102
103	func (p parser) ActivityInfoToBlob(info ActivityInfo) (persistence.DataBlob, error) {	842✔
104	db := persistence.DataBlob{}	842✔
105	data, err := p.encoder.activityInfoToBlob(info)	842✔
106	if err != nil {	842✔
107	return db, err	×
108	}	×
109	db.Data = data	842✔
110	db.Encoding = p.encoder.encodingType()	842✔
111	return db, nil	842✔
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) {	641✔
159	db := persistence.DataBlob{}	641✔
160	data, err := p.encoder.taskInfoToBlob(info)	641✔
161	if err != nil {	641✔
162	return db, err	×
163	}	×
164	db.Data = data	641✔
165	db.Encoding = p.encoder.encodingType()	641✔
166	return db, nil	641✔
167	}
168
169	func (p parser) TaskListInfoToBlob(info TaskListInfo) (persistence.DataBlob, error) {	5,657✔
170	db := persistence.DataBlob{}	5,657✔
171	data, err := p.encoder.taskListInfoToBlob(info)	5,657✔
172	if err != nil {	5,657✔
173	return db, err	×
174	}	×
175	db.Data = data	5,657✔
176	db.Encoding = p.encoder.encodingType()	5,657✔
177	return db, nil	5,657✔
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,115✔
203	db := persistence.DataBlob{}	2,115✔
204	data, err := p.encoder.timerTaskInfoToBlob(info)	2,115✔
205	if err != nil {	2,115✔
206	return db, err	×
207	}	×
208	db.Data = data	2,115✔
209	db.Encoding = p.encoder.encodingType()	2,115✔
210	return db, nil	2,115✔
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,077✔
233	decoder, err := p.getCachedDecoder(common.EncodingType(encoding))	3,077✔
234	if err != nil {	3,077✔
235	return nil, err	×
236	}	×
237	return decoder.domainInfoFromBlob(data)	3,077✔
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) {	495✔
249	decoder, err := p.getCachedDecoder(common.EncodingType(encoding))	495✔
250	if err != nil {	495✔
251	return nil, err	×
252	}	×
253	return decoder.workflowExecutionInfoFromBlob(data)	495✔
254	}
255
256	func (p parser) ActivityInfoFromBlob(data []byte, encoding string) (ActivityInfo, error) {	71✔
257	decoder, err := p.getCachedDecoder(common.EncodingType(encoding))	71✔
258	if err != nil {	71✔
259	return nil, err	×
260	}	×
261	return decoder.activityInfoFromBlob(data)	71✔
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) {	1✔
273	decoder, err := p.getCachedDecoder(common.EncodingType(encoding))	1✔
274	if err != nil {	1✔
275	return nil, err	×
276	}	×
277	return decoder.signalInfoFromBlob(data)	1✔
278	}
279
280	func (p parser) RequestCancelInfoFromBlob(data []byte, encoding string) (RequestCancelInfo, error) {	×
281	decoder, err := p.getCachedDecoder(common.EncodingType(encoding))	×
282	if err != nil {	×
283	return nil, err	×
284	}	×
285	return decoder.requestCancelInfoFromBlob(data)	×
286	}
287
288	func (p parser) TimerInfoFromBlob(data []byte, encoding string) (TimerInfo, error) {	×
289	decoder, err := p.getCachedDecoder(common.EncodingType(encoding))	×
290	if err != nil {	×
291	return nil, err	×
292	}	×
293	return decoder.timerInfoFromBlob(data)	×
294	}
295
296	func (p parser) TaskInfoFromBlob(data []byte, encoding string) (TaskInfo, error) {	641✔
297	decoder, err := p.getCachedDecoder(common.EncodingType(encoding))	641✔
298	if err != nil {	641✔
299	return nil, err	×
300	}	×
301	return decoder.taskInfoFromBlob(data)	641✔
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,744✔
313	decoder, err := p.getCachedDecoder(common.EncodingType(encoding))	3,744✔
314	if err != nil {	3,744✔
315	return nil, err	×
316	}	×
317	return decoder.transferTaskInfoFromBlob(data)	3,744✔
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,928✔
329	decoder, err := p.getCachedDecoder(common.EncodingType(encoding))	5,928✔
330	if err != nil {	5,928✔
331	return nil, err	×
332	}	×
333	return decoder.timerTaskInfoFromBlob(data)	5,928✔
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,898✔
345	decoder, ok := p.decoders[encoding]	14,898✔
346	if !ok {	14,898✔
347	return nil, unsupportedEncodingError(encoding)	×
348	}	×
349	return decoder, nil	14,898✔
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 / 0186ed8c-939f-4cc5-9459-fac2c80653f9

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