go.temporal.io/server/tools/tdbg/util.go
322 LOC · 68 covered · 254 uncovered · 23 ranges · 81 concepts · 13 introducers · 39 tests
File neighbourhood
The centred file is linked to every concept that introduces one of its ranges, every test that runs code from the file, and the gray connector concepts standing between those tests and the file's own introducer concepts. Undirected links join concepts to every file where they introduce source and concepts to the tests they introduce; arrows show specialization between the displayed concepts and bridge only concepts omitted from this view. Concept colors match the source ranges below; connector concepts have no source color and are shown in gray.
Focused file, its introducer and connector concepts, their introduced files, and tests that run code from the file
In the embedded map, ordinary wheel input scrolls the page; use the visible controls to zoom and drag to pan. Open the full-screen map for canvas navigation: wheel pans, Ctrl/Command plus wheel zooms, and arrow keys pan when this region is focused. On touch screens, open the full-screen map to pan or pinch. If JavaScript or WebGL is unavailable, use the related-file, concept, and source links on this page.
Graph controls are ready.
Interactive rendering requires JavaScript and WebGL. Use the related-file, concept, and source links on this page while the interactive map is unavailable.
1
package tdbg
2
3
import (
4
"context"
5
"encoding/json"
6
"fmt"
7
"io"
8
"os"
9
"reflect"
10
"regexp"
11
"strconv"
12
"strings"
13
"time"
14
15
"github.com/fatih/color"
16
"github.com/olekukonko/tablewriter"
17
"github.com/urfave/cli/v2"
18
"go.temporal.io/api/workflowservice/v1"
19
"go.temporal.io/server/chasm"
20
"go.temporal.io/server/common/codec"
21
"go.temporal.io/server/common/collection"
22
"go.temporal.io/server/common/namespace"
23
"google.golang.org/protobuf/proto"
24
)
25
26
var envKeysForUserName = []string{
27
"USER",
28
"LOGNAME",
29
"HOME",
30
}
31
33
>
for _, n := range envKeysForUserName {
34
>
if len(os.Getenv(n)) > 0 {
35
>
return os.Getenv(n)
36
>
}
37
}
38
return "unknown"
39
}
40
42
>
var b []byte
43
>
var err error
44
>
if pb, ok := o.(proto.Message); ok {
45
>
encoder := codec.NewJSONPBIndentEncoder(" ")
46
>
b, err = encoder.Encode(pb)
47
>
} else {
48
b, err = json.MarshalIndent(o, "", " ")
49
}
50
52
fmt.Fprintf(c.App.ErrWriter, "Error when trying to pretty-print: %v\n%v\n", err, o)
53
return
54
}
55
57
>
_, _ = c.App.Writer.Write([]byte("\n"))
58
}
59
61
>
value := c.String(optionName)
62
>
if len(value) == 0 {
63
return "", fmt.Errorf("option is required: %s", optionName)
64
}
66
}
67
68
func parseTime(timeStr string, defaultValue time.Time, now time.Time) (time.Time, error) {
69
if len(timeStr) == 0 {
70
return defaultValue, nil
71
}
72
73
// try to parse
74
parsedTime, err := time.Parse(defaultDateTimeFormat, timeStr)
75
if err == nil {
76
return parsedTime, nil
77
}
78
79
// treat as raw unix time
80
resultValue, err := strconv.ParseInt(timeStr, 10, 64)
81
if err == nil {
82
return time.Unix(0, resultValue).UTC(), nil
83
}
84
85
// treat as time range format
86
parsedTime, err = parseTimeRange(timeStr, now)
87
if err != nil {
88
return time.Time{}, fmt.Errorf("cannot parse time '%s', use UTC format '2006-01-02T15:04:05', "+
89
"time range or raw UnixNano directly. See help for more details: %s", timeStr, err)
90
}
91
return parsedTime, nil
92
}
93
94
// parseTimeRange parses a given time duration string (in format X<time-duration>) and
95
// returns parsed timestamp given that duration in the past from current time.
96
// All valid values must contain a number followed by a time-duration, from the following list (long form/short form):
97
// - second/s
98
// - minute/m
99
// - hour/h
100
// - day/d
101
// - week/w
102
// - month/M
103
// - year/y
104
// For example, possible input values, and their result:
105
// - "3d" or "3day" --> three days --> time.Now().UTC().Add(-3 * 24 * time.Hour)
106
// - "2m" or "2minute" --> two minutes --> time.Now().UTC().Add(-2 * time.Minute)
107
// - "1w" or "1week" --> one week --> time.Now().UTC().Add(-7 * 24 * time.Hour)
108
// - "30s" or "30second" --> thirty seconds --> time.Now().UTC().Add(-30 * time.Second)
109
// Note: Duration strings are case-sensitive, and should be used as mentioned above only.
110
// Limitation: Value of numerical multiplier, X should be in b/w 0 - 1e6 (1 million), boundary values excluded i.e.
111
// 0 < X < 1e6. Also, the maximum time in the past can be 1 January 1970 00:00:00 UTC (epoch time),
112
// so giving "1000y" will result in epoch time.
113
func parseTimeRange(timeRange string, now time.Time) (time.Time, error) {
114
match, err := regexp.MatchString(defaultDateTimeRangeShortRE, timeRange)
115
if !match { // fallback on to check if it's of longer notation
116
_, err = regexp.MatchString(defaultDateTimeRangeLongRE, timeRange)
117
}
118
if err != nil {
119
return time.Time{}, err
120
}
121
122
re, _ := regexp.Compile(defaultDateTimeRangeNum)
123
idx := re.FindStringSubmatchIndex(timeRange)
124
if idx == nil {
125
return time.Time{}, fmt.Errorf("cannot parse timeRange %s", timeRange)
126
}
127
128
num, err := strconv.Atoi(timeRange[idx[0]:idx[1]])
129
if err != nil {
130
return time.Time{}, fmt.Errorf("cannot parse timeRange %s", timeRange)
131
}
132
if num >= 1e6 {
133
return time.Time{}, fmt.Errorf("invalid time-duation multiplier %d, allowed range is 0 < multiplier < 1000000", num)
134
}
135
136
dur, err := parseTimeDuration(timeRange[idx[1]:])
137
if err != nil {
138
return time.Time{}, fmt.Errorf("cannot parse timeRange %s", timeRange)
139
}
140
141
res := now.Add(time.Duration(-num) * dur) // using server's local timezone
142
epochTime := time.Unix(0, 0).UTC()
143
if res.Before(epochTime) {
144
res = epochTime
145
}
146
return res, nil
147
}
148
149
// parseTimeDuration parses the given time duration in either short or long convention
150
// and returns the time.Duration
151
// Valid values (long notation/short notation):
152
// - second/s
153
// - minute/m
154
// - hour/h
155
// - day/d
156
// - week/w
157
// - month/M
158
// - year/y
159
// NOTE: the input "duration" is case-sensitive
160
func parseTimeDuration(duration string) (dur time.Duration, err error) {
161
switch duration {
162
case "s", "second":
163
dur = time.Second
164
case "m", "minute":
165
dur = time.Minute
166
case "h", "hour":
167
dur = time.Hour
168
case "d", "day":
169
dur = day
170
case "w", "week":
171
dur = week
172
case "M", "month":
173
dur = month
174
case "y", "year":
175
dur = year
176
default:
177
err = fmt.Errorf("unknown time duration %s", duration)
178
}
179
return
180
}
181
183
>
return newContextWithTimeout(c, defaultContextTimeout)
184
>
}
185
186
>
func newContextWithTimeout(c *cli.Context, timeout time.Duration) (context.Context, context.CancelFunc) {
util.go ×3
187
>
if c.IsSet(FlagContextTimeout) {
188
timeout = time.Duration(c.Int(FlagContextTimeout)) * time.Second
189
}
190
192
}
193
195
>
if search == "" {
197
>
}
198
200
>
for key, value := range candidates {
203
>
}
205
}
206
207
>
return 0, fmt.Errorf("could not find corresponding candidate for %s. Possible candidates: %q", search, candidateNames)
util.go ×1
208
}
209
210
// paginate creates an interactive CLI mode to control the printing of items
211
func paginate[V any](c *cli.Context, paginationFn collection.PaginationFn[V], pageSize int) error {
212
more := c.Bool(FlagMore)
213
isTableView := !c.Bool(FlagPrintJSON)
214
iter := collection.NewPagingIterator(paginationFn)
215
216
var pageItems []any
217
for iter.HasNext() {
218
item, err := iter.Next()
219
if err != nil {
220
return err
221
}
222
223
pageItems = append(pageItems, item)
224
if len(pageItems) == pageSize || !iter.HasNext() {
225
if isTableView {
226
if err := printTable(pageItems, c.App.Writer); err != nil {
227
return err
228
}
229
} else {
230
prettyPrintJSONObject(c, pageItems)
231
}
232
233
if !more || !showNextPage(c.App.Writer) {
234
break
235
}
236
pageItems = pageItems[:0]
237
}
238
}
239
240
return nil
241
}
242
243
var exportRgx = regexp.MustCompile("^[A-Z]")
244
246
>
if len(items) == 0 {
248
>
}
249
251
>
for e.Type().Kind() == reflect.Pointer {
252
e = e.Elem()
253
}
254
256
>
var exportedFields []int
257
>
t := e.Type()
258
>
for i := 0; i < e.NumField(); i++ {
259
>
if exportRgx.MatchString(t.Field(i).Name) {
260
>
fields = append(fields, t.Field(i).Name)
261
>
exportedFields = append(exportedFields, i)
262
>
}
263
}
264
266
>
table.SetBorder(false)
267
>
table.SetColumnSeparator("|")
268
>
table.SetHeader(fields)
269
>
table.SetHeaderLine(false)
270
>
for i := range items {
271
>
item := reflect.ValueOf(items[i])
272
>
for item.Type().Kind() == reflect.Pointer {
273
item = item.Elem()
274
}
276
>
for _, j := range exportedFields {
277
>
col := item.Field(j)
278
>
columns = append(columns, fmt.Sprintf("%v", col.Interface()))
279
>
}
280
>
table.Append(columns)
281
}
283
>
table.ClearRows()
284
>
285
>
return nil
286
}
287
288
func showNextPage(wr io.Writer) bool {
289
fmt.Fprintf(wr, "Press %s to show next page, press %s to quit: ",
290
color.GreenString("Enter"), color.RedString("any other key then Enter"))
291
var input string
292
_, _ = fmt.Scanln(&input)
293
return strings.Trim(input, " ") == ""
294
}
295
296
func getNamespaceID(c *cli.Context, clientFactory ClientFactory, nsName namespace.Name) (namespace.ID, error) {
297
wfClient := clientFactory.WorkflowClient(c)
298
299
ctx, cancel := newContext(c)
300
defer cancel()
301
302
nsResponse, err := wfClient.DescribeNamespace(ctx, &workflowservice.DescribeNamespaceRequest{
303
Namespace: nsName.String(),
304
})
305
if err != nil {
306
return namespace.EmptyID, err
307
}
308
309
return namespace.ID(nsResponse.NamespaceInfo.GetId()), nil
310
}
311
312
func getArchetype(c *cli.Context) chasm.Archetype {
313
if c.IsSet(FlagArchetypeID) {
314
return ""
315
}
316
317
archetype := c.String(FlagArchetype)
318
if archetype != "" {
319
return archetype
320
}
321
return chasm.WorkflowArchetype
322
}