]> ruderich.org/simon Gitweb - safcm/safcm.git/blob - cmd/safcm-remote/sync/services_systemd.go
config: disallow negative permissions
[safcm/safcm.git] / cmd / safcm-remote / sync / services_systemd.go
1 // MsgSyncReq: enable and start services on the remote host (systemd)
2
3 // Copyright (C) 2021  Simon Ruderich
4 //
5 // This program is free software: you can redistribute it and/or modify
6 // it under the terms of the GNU General Public License as published by
7 // the Free Software Foundation, either version 3 of the License, or
8 // (at your option) any later version.
9 //
10 // This program is distributed in the hope that it will be useful,
11 // but WITHOUT ANY WARRANTY; without even the implied warranty of
12 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13 // GNU General Public License for more details.
14 //
15 // You should have received a copy of the GNU General Public License
16 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
17
18 package sync
19
20 import (
21         "fmt"
22         "strings"
23
24         "ruderich.org/simon/safcm"
25 )
26
27 func (s *Sync) syncServicesSystemd() error {
28         s.log.Debugf("services: detected systemd")
29
30         s.log.Debugf("services: checking %s",
31                 strings.Join(s.req.Services, " "))
32         services, err := s.systemdServiceState(s.req.Services)
33         if err != nil {
34                 return err
35         }
36
37         var start, enable []string
38         for _, name := range s.req.Services {
39                 var change safcm.ServiceChange
40
41                 x := services[name]
42                 if x.ActiveState != "active" {
43                         start = append(start, name)
44                         change.Started = true
45                 }
46                 if x.UnitFileState != "enabled" {
47                         enable = append(enable, name)
48                         change.Enabled = true
49                 }
50
51                 if change.Started || change.Enabled {
52                         change.Name = name
53                         s.resp.ServiceChanges = append(s.resp.ServiceChanges,
54                                 change)
55                 }
56         }
57         if len(start) == 0 && len(enable) == 0 {
58                 return nil
59         }
60
61         if s.req.DryRun {
62                 return nil
63         }
64
65         // Reload service files which were possibly changed during file sync
66         // or package installation
67         _, _, err = s.cmd.Run("services", "/bin/systemctl", "daemon-reload")
68         if err != nil {
69                 return err
70         }
71         if len(start) != 0 {
72                 s.log.Verbosef("services: starting %s",
73                         strings.Join(start, " "))
74                 _, _, err := s.cmd.Run("services", append([]string{
75                         "/bin/systemctl", "start", "--",
76                 }, start...)...)
77                 if err != nil {
78                         return err
79                 }
80         }
81         if len(enable) != 0 {
82                 s.log.Verbosef("services: enabling %s",
83                         strings.Join(enable, " "))
84                 _, _, err := s.cmd.Run("services", append([]string{
85                         "/bin/systemctl", "enable", "--",
86                 }, enable...)...)
87                 if err != nil {
88                         return err
89                 }
90         }
91
92         return nil
93 }
94
95 type SystemdService struct {
96         ActiveState   string
97         UnitFileState string
98 }
99
100 func (s *Sync) systemdServiceState(services []string) (
101         map[string]SystemdService, error) {
102
103         out, _, err := s.cmd.Run("services", append([]string{
104                 "/bin/systemctl",
105                 "show",
106                 "--property=ActiveState,UnitFileState,LoadError",
107                 "--",
108         }, services...)...)
109         if err != nil {
110                 return nil, err
111         }
112
113         i := 0
114
115         res := make(map[string]SystemdService)
116         for _, block := range strings.Split(string(out), "\n\n") {
117                 lines := strings.Split(strings.TrimSpace(block), "\n")
118                 if len(lines) != 3 {
119                         return nil, fmt.Errorf("invalid systemctl output: %q",
120                                 block)
121                 }
122
123                 var service SystemdService
124                 for _, x := range lines {
125                         const (
126                                 activePrefix = "ActiveState="
127                                 unitPrefix   = "UnitFileState="
128                                 errorPrefix  = "LoadError="
129                         )
130
131                         if strings.HasPrefix(x, activePrefix) {
132                                 service.ActiveState = strings.TrimPrefix(x,
133                                         activePrefix)
134                         } else if strings.HasPrefix(x, unitPrefix) {
135                                 service.UnitFileState = strings.TrimPrefix(x,
136                                         unitPrefix)
137                         } else if strings.HasPrefix(x, errorPrefix) {
138                                 x := strings.TrimPrefix(x, errorPrefix)
139                                 // Older systemd versions (e.g. 237) add empty
140                                 // quotes even if there is no error
141                                 if x != "" && x != ` ""` {
142                                         return nil, fmt.Errorf(
143                                                 "systemd unit %q not found",
144                                                 services[i])
145                                 }
146                         } else {
147                                 return nil, fmt.Errorf(
148                                         "invalid systemctl show line %q", x)
149                         }
150                 }
151                 res[services[i]] = service
152
153                 i++
154         }
155
156         return res, nil
157 }