2112616778

Committed 02 Sep 2025 11:04AM UTC coverage: 69.56% (-0.1%) from 69.672%

Build # 2112616778

Build Type

push

gitlab-ci

Committed by

web-flow

Commit Message

Merge pull request #161 from mendersoftware/dependabot/go_modules/github.com/stretchr/testify-1.11.1

chore: bump github.com/stretchr/testify from 1.10.0 to 1.11.1

Run Details

2484 of 3571 relevant lines covered (69.56%)

6.23 hits per line

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

65.22

/app/daemon_shell.go

// Copyright 2022 Northern.tech AS
//
//        Licensed under the Apache License, Version 2.0 (the "License");
//        you may not use this file except in compliance with the License.
//        You may obtain a copy of the License at
//
//            http://www.apache.org/licenses/LICENSE-2.0
//
//        Unless required by applicable law or agreed to in writing, software
//        distributed under the License is distributed on an "AS IS" BASIS,
//        WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
//        See the License for the specific language governing permissions and
//        limitations under the License.
package app

import (
        "fmt"

        "github.com/mendersoftware/go-lib-micro/ws"
        wsshell "github.com/mendersoftware/go-lib-micro/ws/shell"
        "github.com/pkg/errors"
        log "github.com/sirupsen/logrus"

        "github.com/mendersoftware/mender-connect/config"
        "github.com/mendersoftware/mender-connect/procps"
        "github.com/mendersoftware/mender-connect/session"
        "github.com/mendersoftware/mender-connect/utils"
)

const (
        propertyTerminalHeight = "terminal_height"
        propertyTerminalWidth  = "terminal_width"
        propertyUserID         = "user_id"
)

func getUserIdFromMessage(message *ws.ProtoMsg) string {
        userID, _ := message.Header.Properties[propertyUserID].(string)
        return userID
}

func (d *MenderShellDaemon) routeMessageSpawnShell(message *ws.ProtoMsg) error {
        var err error
        response := &ws.ProtoMsg{
                Header: ws.ProtoHdr{
                        Proto:     message.Header.Proto,
                        MsgType:   message.Header.MsgType,
                        SessionID: message.Header.SessionID,
                        Properties: map[string]interface{}{
                                "status": wsshell.NormalMessage,
                        },
                },
                Body: []byte{},
        }
        if d.shellsSpawned >= config.MaxShellsSpawned {
                err = session.ErrSessionTooManyShellsAlreadyRunning
                d.routeMessageResponse(response, err)
                return err
        }
        s := session.MenderShellSessionGetById(message.Header.SessionID)
        if s == nil {
                userId := getUserIdFromMessage(message)
                if s, err = session.NewMenderShellSession(
                        message.Header.SessionID,
                        userId,
                        d.expireSessionsAfter,
                        d.expireSessionsAfterIdle,
                ); err != nil {
                        d.routeMessageResponse(response, err)
                        return err
                }
                log.Debugf("created a new session: %s", s.GetId())
        }

        response.Header.SessionID = s.GetId()

        terminalHeight := d.TerminalConfig.Height
        terminalWidth := d.TerminalConfig.Width

        requestedHeight, requestedWidth := mapPropertiesToTerminalHeightAndWidth(
                message.Header.Properties,
        )
        if requestedHeight > 0 && requestedWidth > 0 {
                terminalHeight = requestedHeight
                terminalWidth = requestedWidth
        }

        log.Debugf("starting shell session_id=%s", s.GetId())
        if err = s.StartShell(s.GetId(), session.MenderShellTerminalSettings{
                Uid:            uint32(d.uid),
                Gid:            uint32(d.gid),
                Gids:           d.gids,
                Shell:          d.shell,
                HomeDir:        d.homeDir,
                TerminalString: d.terminalString,
                Height:         terminalHeight,
                Width:          terminalWidth,
                ShellArguments: d.shellArguments,
        }); err != nil {
                err = errors.Wrap(err, "failed to start shell")
                d.routeMessageResponse(response, err)
                return err
        }

        log.Debug("Shell started")
        d.shellsSpawned++

        response.Body = []byte("Shell started")
        d.routeMessageResponse(response, err)
        return nil
}

func (d *MenderShellDaemon) routeMessageStopShell(message *ws.ProtoMsg) error {
        var err error
        response := &ws.ProtoMsg{
                Header: ws.ProtoHdr{
                        Proto:     message.Header.Proto,
                        MsgType:   message.Header.MsgType,
                        SessionID: message.Header.SessionID,
                        Properties: map[string]interface{}{
                                "status": wsshell.NormalMessage,
                        },
                },
                Body: []byte{},
        }

        if len(message.Header.SessionID) < 1 {
                userId := getUserIdFromMessage(message)
                if len(userId) < 1 {
                        err = errors.New("StopShellMessage: sessionId not given and userId empty")
                        d.routeMessageResponse(response, err)
                        return err
                }
                shellsStoppedCount, err := session.MenderShellStopByUserId(userId)
                if err == nil {
                        if shellsStoppedCount > d.shellsSpawned {
                                d.shellsSpawned = 0
                                err = errors.New(fmt.Sprintf("StopByUserId: the shells stopped count (%d) "+
                                        "greater than total shells spawned (%d). resetting shells "+
                                        "spawned to 0.", shellsStoppedCount, d.shellsSpawned))
                                d.routeMessageResponse(response, err)
                                return err
                        } else {
                                log.Debugf("StopByUserId: stopped %d shells.", shellsStoppedCount)
                                d.DecreaseSpawnedShellsCount(shellsStoppedCount)
                        }
                }
                d.routeMessageResponse(response, err)
                return err
        }

        s := session.MenderShellSessionGetById(message.Header.SessionID)
        if s == nil {
                err = errors.New(
                        fmt.Sprintf(
                                "routeMessage: StopShellMessage: session not found for id %s",
                                message.Header.SessionID,
                        ),
                )
                d.routeMessageResponse(response, err)
                return err
        }

        err = s.StopShell()
        if err != nil {
                if procps.ProcessExists(s.GetShellPid()) {
                        log.Errorf("could not terminate shell (pid %d) for session %s, user"+
                                "will not be able to start another one if the limit is reached.",
                                s.GetShellPid(),
                                s.GetId())
                        err = errors.New("could not terminate shell: " + err.Error() + ".")
                        d.routeMessageResponse(response, err)
                        return err
                } else {
                        log.Errorf("process error on exit: %s", err.Error())
                }
        }
        if d.shellsSpawned == 0 {
                log.Warn("can't decrement shellsSpawned count: it is 0.")
        } else {
                d.shellsSpawned--
        }
        err = session.MenderShellDeleteById(s.GetId())
        d.routeMessageResponse(response, err)
        return err
}

func (d *MenderShellDaemon) routeMessageShellCommand(message *ws.ProtoMsg) error {
        var err error
        response := &ws.ProtoMsg{
                Header: ws.ProtoHdr{
                        Proto:     message.Header.Proto,
                        MsgType:   message.Header.MsgType,
                        SessionID: message.Header.SessionID,
                        Properties: map[string]interface{}{
                                "status": wsshell.NormalMessage,
                        },
                },
                Body: []byte{},
        }

        s := session.MenderShellSessionGetById(message.Header.SessionID)
        if s == nil {
                err = session.ErrSessionNotFound
                d.routeMessageResponse(response, err)
                return err
        }
        err = s.ShellCommand(message)
        if err != nil {
                err = errors.Wrapf(
                        err,
                        "routeMessage: shell command execution error, session_id=%s",
                        message.Header.SessionID,
                )
                d.routeMessageResponse(response, err)
                return err
        }
        return nil
}

func mapPropertiesToTerminalHeightAndWidth(properties map[string]interface{}) (uint16, uint16) {
        var terminalHeight, terminalWidth uint16
        requestedHeight, requestedHeightOk := properties[propertyTerminalHeight]
        requestedWidth, requestedWidthOk := properties[propertyTerminalWidth]
        if requestedHeightOk && requestedWidthOk {
                if val, _ := utils.Num64(requestedHeight); val > 0 {
                        terminalHeight = uint16(val)
                }
                if val, _ := utils.Num64(requestedWidth); val > 0 {
                        terminalWidth = uint16(val)
                }
        }
        return terminalHeight, terminalWidth
}

func (d *MenderShellDaemon) routeMessageShellResize(message *ws.ProtoMsg) error {
        var err error

        s := session.MenderShellSessionGetById(message.Header.SessionID)
        if s == nil {
                err = session.ErrSessionNotFound
                log.Error(err.Error())
                return err
        }

        terminalHeight, terminalWidth := mapPropertiesToTerminalHeightAndWidth(
                message.Header.Properties,
        )
        if terminalHeight > 0 && terminalWidth > 0 {
                s.ResizeShell(terminalHeight, terminalWidth)
        }
        return nil
}

func (d *MenderShellDaemon) routeMessagePongShell(message *ws.ProtoMsg) error {
        var err error

        s := session.MenderShellSessionGetById(message.Header.SessionID)
        if s == nil {
                err = session.ErrSessionNotFound
                log.Error(err.Error())
                return err
        }

        s.HealthcheckPong()
        return nil
}

1	// Copyright 2022 Northern.tech AS
2	//
3	// Licensed under the Apache License, Version 2.0 (the "License");
4	// you may not use this file except in compliance with the License.
5	// You may obtain a copy of the License at
6	//
7	// http://www.apache.org/licenses/LICENSE-2.0
8	//
9	// Unless required by applicable law or agreed to in writing, software
10	// distributed under the License is distributed on an "AS IS" BASIS,
11	// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12	// See the License for the specific language governing permissions and
13	// limitations under the License.
14	package app
15
16	import (
17	"fmt"
18
19	"github.com/mendersoftware/go-lib-micro/ws"
20	wsshell "github.com/mendersoftware/go-lib-micro/ws/shell"
21	"github.com/pkg/errors"
22	log "github.com/sirupsen/logrus"
23
24	"github.com/mendersoftware/mender-connect/config"
25	"github.com/mendersoftware/mender-connect/procps"
26	"github.com/mendersoftware/mender-connect/session"
27	"github.com/mendersoftware/mender-connect/utils"
28	)
29
30	const (
31	propertyTerminalHeight = "terminal_height"
32	propertyTerminalWidth = "terminal_width"
33	propertyUserID = "user_id"
34	)
35
36	func getUserIdFromMessage(message *ws.ProtoMsg) string {	7✔
37	userID, _ := message.Header.Properties[propertyUserID].(string)	7✔
38	return userID	7✔
39	}	7✔
40
41	func (d MenderShellDaemon) routeMessageSpawnShell(message ws.ProtoMsg) error {	8✔
42	var err error	8✔
43	response := &ws.ProtoMsg{	8✔
44	Header: ws.ProtoHdr{	8✔
45	Proto: message.Header.Proto,	8✔
46	MsgType: message.Header.MsgType,	8✔
47	SessionID: message.Header.SessionID,	8✔
48	Properties: map[string]interface{}{	8✔
49	"status": wsshell.NormalMessage,	8✔
50	},	8✔
51	},	8✔
52	Body: []byte{},	8✔
53	}	8✔
54	if d.shellsSpawned >= config.MaxShellsSpawned {	9✔
55	err = session.ErrSessionTooManyShellsAlreadyRunning	1✔
56	d.routeMessageResponse(response, err)	1✔
57	return err	1✔
58	}	1✔
59	s := session.MenderShellSessionGetById(message.Header.SessionID)	7✔
60	if s == nil {	14✔
61	userId := getUserIdFromMessage(message)	7✔
62	if s, err = session.NewMenderShellSession(	7✔
63	message.Header.SessionID,	7✔
64	userId,	7✔
65	d.expireSessionsAfter,	7✔
66	d.expireSessionsAfterIdle,	7✔
67	); err != nil {	8✔
68	d.routeMessageResponse(response, err)	1✔
69	return err	1✔
70	}	1✔
71	log.Debugf("created a new session: %s", s.GetId())	6✔
72	}
73
74	response.Header.SessionID = s.GetId()	6✔
75		6✔
76	terminalHeight := d.TerminalConfig.Height	6✔
77	terminalWidth := d.TerminalConfig.Width	6✔
78		6✔
79	requestedHeight, requestedWidth := mapPropertiesToTerminalHeightAndWidth(	6✔
80	message.Header.Properties,	6✔
81	)	6✔
82	if requestedHeight > 0 && requestedWidth > 0 {	12✔
83	terminalHeight = requestedHeight	6✔
84	terminalWidth = requestedWidth	6✔
85	}	6✔
86
87	log.Debugf("starting shell session_id=%s", s.GetId())	6✔
88	if err = s.StartShell(s.GetId(), session.MenderShellTerminalSettings{	6✔
89	Uid: uint32(d.uid),	6✔
90	Gid: uint32(d.gid),	6✔
91	Gids: d.gids,	6✔
92	Shell: d.shell,	6✔
93	HomeDir: d.homeDir,	6✔
94	TerminalString: d.terminalString,	6✔
95	Height: terminalHeight,	6✔
96	Width: terminalWidth,	6✔
97	ShellArguments: d.shellArguments,	6✔
98	}); err != nil {	6✔
99	err = errors.Wrap(err, "failed to start shell")	×
100	d.routeMessageResponse(response, err)	×
101	return err	×
102	}	×
103
104	log.Debug("Shell started")	6✔
105	d.shellsSpawned++	6✔
106		6✔
107	response.Body = []byte("Shell started")	6✔
108	d.routeMessageResponse(response, err)	6✔
109	return nil	6✔
110	}
111
112	func (d MenderShellDaemon) routeMessageStopShell(message ws.ProtoMsg) error {	4✔
113	var err error	4✔
114	response := &ws.ProtoMsg{	4✔
115	Header: ws.ProtoHdr{	4✔
116	Proto: message.Header.Proto,	4✔
117	MsgType: message.Header.MsgType,	4✔
118	SessionID: message.Header.SessionID,	4✔
119	Properties: map[string]interface{}{	4✔
120	"status": wsshell.NormalMessage,	4✔
121	},	4✔
122	},	4✔
123	Body: []byte{},	4✔
124	}	4✔
125		4✔
126	if len(message.Header.SessionID) < 1 {	4✔
127	userId := getUserIdFromMessage(message)	×
128	if len(userId) < 1 {	×
129	err = errors.New("StopShellMessage: sessionId not given and userId empty")	×
130	d.routeMessageResponse(response, err)	×
131	return err	×
132	}	×
133	shellsStoppedCount, err := session.MenderShellStopByUserId(userId)	×
134	if err == nil {	×
135	if shellsStoppedCount > d.shellsSpawned {	×
136	d.shellsSpawned = 0	×
137	err = errors.New(fmt.Sprintf("StopByUserId: the shells stopped count (%d) "+	×
138	"greater than total shells spawned (%d). resetting shells "+	×
139	"spawned to 0.", shellsStoppedCount, d.shellsSpawned))	×
140	d.routeMessageResponse(response, err)	×
141	return err	×
142	} else {	×
143	log.Debugf("StopByUserId: stopped %d shells.", shellsStoppedCount)	×
144	d.DecreaseSpawnedShellsCount(shellsStoppedCount)	×
145	}	×
146	}
147	d.routeMessageResponse(response, err)	×
148	return err	×
149	}
150
151	s := session.MenderShellSessionGetById(message.Header.SessionID)	4✔
152	if s == nil {	6✔
153	err = errors.New(	2✔
154	fmt.Sprintf(	2✔
155	"routeMessage: StopShellMessage: session not found for id %s",	2✔
156	message.Header.SessionID,	2✔
157	),	2✔
158	)	2✔
159	d.routeMessageResponse(response, err)	2✔
160	return err	2✔
161	}	2✔
162
163	err = s.StopShell()	2✔
164	if err != nil {	2✔
165	if procps.ProcessExists(s.GetShellPid()) {	×
166	log.Errorf("could not terminate shell (pid %d) for session %s, user"+	×
167	"will not be able to start another one if the limit is reached.",	×
168	s.GetShellPid(),	×
169	s.GetId())	×
170	err = errors.New("could not terminate shell: " + err.Error() + ".")	×
171	d.routeMessageResponse(response, err)	×
172	return err	×
173	} else {	×
174	log.Errorf("process error on exit: %s", err.Error())	×
175	}	×
176	}
177	if d.shellsSpawned == 0 {	2✔
178	log.Warn("can't decrement shellsSpawned count: it is 0.")	×
179	} else {	2✔
180	d.shellsSpawned--	2✔
181	}	2✔
182	err = session.MenderShellDeleteById(s.GetId())	2✔
183	d.routeMessageResponse(response, err)	2✔
184	return err	2✔
185	}
186
187	func (d MenderShellDaemon) routeMessageShellCommand(message ws.ProtoMsg) error {	3✔
188	var err error	3✔
189	response := &ws.ProtoMsg{	3✔
190	Header: ws.ProtoHdr{	3✔
191	Proto: message.Header.Proto,	3✔
192	MsgType: message.Header.MsgType,	3✔
193	SessionID: message.Header.SessionID,	3✔
194	Properties: map[string]interface{}{	3✔
195	"status": wsshell.NormalMessage,	3✔
196	},	3✔
197	},	3✔
198	Body: []byte{},	3✔
199	}	3✔
200		3✔
201	s := session.MenderShellSessionGetById(message.Header.SessionID)	3✔
202	if s == nil {	4✔
203	err = session.ErrSessionNotFound	1✔
204	d.routeMessageResponse(response, err)	1✔
205	return err	1✔
206	}	1✔
207	err = s.ShellCommand(message)	2✔
208	if err != nil {	2✔
209	err = errors.Wrapf(	×
210	err,	×
211	"routeMessage: shell command execution error, session_id=%s",	×
212	message.Header.SessionID,	×
213	)	×
214	d.routeMessageResponse(response, err)	×
215	return err	×
216	}	×
217	return nil	2✔
218	}
219
220	func mapPropertiesToTerminalHeightAndWidth(properties map[string]interface{}) (uint16, uint16) {	6✔
221	var terminalHeight, terminalWidth uint16	6✔
222	requestedHeight, requestedHeightOk := properties[propertyTerminalHeight]	6✔
223	requestedWidth, requestedWidthOk := properties[propertyTerminalWidth]	6✔
224	if requestedHeightOk && requestedWidthOk {	12✔
225	if val, _ := utils.Num64(requestedHeight); val > 0 {	12✔
226	terminalHeight = uint16(val)	6✔
227	}	6✔
228	if val, _ := utils.Num64(requestedWidth); val > 0 {	12✔
229	terminalWidth = uint16(val)	6✔
230	}	6✔
231	}
232	return terminalHeight, terminalWidth	6✔
233	}
234
235	func (d MenderShellDaemon) routeMessageShellResize(message ws.ProtoMsg) error {	×
236	var err error	×
237		×
238	s := session.MenderShellSessionGetById(message.Header.SessionID)	×
239	if s == nil {	×
240	err = session.ErrSessionNotFound	×
241	log.Error(err.Error())	×
242	return err	×
243	}	×
244
245	terminalHeight, terminalWidth := mapPropertiesToTerminalHeightAndWidth(	×
246	message.Header.Properties,	×
247	)	×
248	if terminalHeight > 0 && terminalWidth > 0 {	×
249	s.ResizeShell(terminalHeight, terminalWidth)	×
250	}	×
251	return nil	×
252	}
253
254	func (d MenderShellDaemon) routeMessagePongShell(message ws.ProtoMsg) error {	×
255	var err error	×
256		×
257	s := session.MenderShellSessionGetById(message.Header.SessionID)	×
258	if s == nil {	×
259	err = session.ErrSessionNotFound	×
260	log.Error(err.Error())	×
261	return err	×
262	}	×
263
264	s.HealthcheckPong()	×
265	return nil	×
266	}

mendersoftware / mender-connect / 2112616778

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