-
Notifications
You must be signed in to change notification settings - Fork 291
/
server.go
157 lines (131 loc) · 3.87 KB
/
server.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
//
// (C) Copyright 2021-2023 Intel Corporation.
//
// SPDX-License-Identifier: BSD-2-Clause-Patent
//
package control
import (
"context"
"fmt"
"strings"
"github.com/pkg/errors"
"google.golang.org/grpc"
"google.golang.org/protobuf/proto"
ctlpb "github.com/daos-stack/daos/src/control/common/proto/ctl"
"github.com/daos-stack/daos/src/control/server/engine"
)
// SetEngineLogMasksReq contains the inputs for the set engine log level request.
type SetEngineLogMasksReq struct {
unaryRequest
Masks *string `json:"masks"`
Streams *string `json:"streams"`
Subsystems *string `json:"subsystems"`
}
// SetEngineLogMasksResp contains the results of a set engine log level request.
type SetEngineLogMasksResp struct {
HostErrorsResp
HostStorage HostStorageMap
}
// addHostResponse is responsible for validating the given HostResponse and adding it to the
// SetEngineLogMaskResp. HostStorageSet will always be empty so the map will only ever have one
// key for this response type.
func (resp *SetEngineLogMasksResp) addHostResponse(hr *HostResponse) error {
pbResp, ok := hr.Message.(*ctlpb.SetLogMasksResp)
if !ok {
return errors.Errorf("unable to unpack message: %+v", hr.Message)
}
hasErr := false
hostErrStrs := pbResp.GetErrors()
for _, strErr := range hostErrStrs {
if strErr != "" {
hasErr = true
break
}
}
if hasErr {
msgEngines := make([]string, len(hostErrStrs))
for i, se := range hostErrStrs {
if se == "" {
se = "updated"
}
msgEngines[i] = fmt.Sprintf("engine-%d: %s", i, se)
}
errEngines := errors.New(strings.Join(msgEngines, ", "))
if err := resp.addHostError(hr.Addr, errEngines); err != nil {
return errors.Wrap(err, "adding host error to response")
}
return nil
}
if resp.HostStorage == nil {
resp.HostStorage = make(HostStorageMap)
}
if err := resp.HostStorage.Add(hr.Addr, new(HostStorage)); err != nil {
return err
}
return nil
}
// Set reset flags if parameters have not been supplied in the input request and dereference values
// if they have after validating.
func setLogMasksReqToPB(req *SetEngineLogMasksReq) (*ctlpb.SetLogMasksReq, error) {
pbReq := new(ctlpb.SetLogMasksReq)
if req.Masks == nil {
pbReq.ResetMasks = true
} else {
if err := engine.ValidateLogMasks(*req.Masks); err != nil {
return nil, err
}
pbReq.Masks = *req.Masks
}
if req.Streams == nil {
pbReq.ResetStreams = true
} else {
if err := engine.ValidateLogStreams(*req.Streams); err != nil {
return nil, err
}
pbReq.Streams = *req.Streams
}
if req.Subsystems == nil {
pbReq.ResetSubsystems = true
} else {
if err := engine.ValidateLogSubsystems(*req.Subsystems); err != nil {
return nil, err
}
pbReq.Subsystems = *req.Subsystems
}
return pbReq, nil
}
// SetEngineLogMasks will send RPC to hostlist to request changes to log level of all DAOS engines
// on each host in list.
func SetEngineLogMasks(ctx context.Context, rpcClient UnaryInvoker, req *SetEngineLogMasksReq) (*SetEngineLogMasksResp, error) {
if req == nil {
return nil, errors.New("nil request")
}
pbReq, err := setLogMasksReqToPB(req)
if err != nil {
return nil, err
}
pbReq.Sys = req.getSystem(rpcClient)
req.setRPC(func(ctx context.Context, conn *grpc.ClientConn) (proto.Message, error) {
return ctlpb.NewCtlSvcClient(conn).SetEngineLogMasks(ctx, pbReq)
})
rpcClient.Debugf("DAOS set engine log masks request: %+v", pbReq)
ur, err := rpcClient.InvokeUnaryRPC(ctx, req)
if err != nil {
rpcClient.Debugf("failed to invoke set engine log masks RPC: %s", err)
return nil, err
}
resp := new(SetEngineLogMasksResp)
for _, hr := range ur.Responses {
if hr.Error != nil {
if err := resp.addHostError(hr.Addr, hr.Error); err != nil {
return nil, err
}
continue
}
if err := resp.addHostResponse(hr); err != nil {
return nil, err
}
}
rpcClient.Debugf("DAOS set engine log masks response: %+v", resp)
return resp, nil
}