forked from realvnc-labs/tacoscript
-
Notifications
You must be signed in to change notification settings - Fork 0
Expand file tree
/
Copy pathmanager.go
More file actions
142 lines (113 loc) · 3.79 KB
/
Copy pathmanager.go
File metadata and controls
142 lines (113 loc) · 3.79 KB
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
package pkg
import (
"bytes"
"context"
"fmt"
"github.com/cloudradar-monitoring/tacoscript/conv"
"github.com/cloudradar-monitoring/tacoscript/exec"
"github.com/cloudradar-monitoring/tacoscript/tasks"
"github.com/sirupsen/logrus"
)
type ManagementCmds struct {
VersionCmd string
UpgradeCmd string
InstallCmds []string
UninstallCmds []string
UpgradeCmds []string
}
type ManagementCmdsProvider interface {
GetManagementCmds(t *tasks.PkgTask) (*ManagementCmds, error)
}
type PackageTaskManager struct {
Runner exec.Runner
PackageManagerCmdProviders []ManagementCmdsProvider
}
func (pm PackageTaskManager) ExecuteTask(ctx context.Context, t *tasks.PkgTask) (output string, err error) {
if len(pm.PackageManagerCmdProviders) == 0 {
err = fmt.Errorf("no package manager providers for the current OS ")
return
}
var managementCmds *ManagementCmds
for _, managementCmdProvider := range pm.PackageManagerCmdProviders {
managementCmds, err = managementCmdProvider.GetManagementCmds(t)
if err != nil {
return "", err
}
logrus.Debugf("will execute version command %s to check if package manager is installed", managementCmds.VersionCmd)
output, err = pm.run(ctx, t, managementCmds.VersionCmd)
if err == nil {
logrus.Debugf("version command success: %s, will use it for further package management", managementCmds.VersionCmd)
break
}
}
if err != nil {
return
}
output, err = pm.updatePkgManagerIfNeeded(ctx, t, managementCmds)
if err != nil {
return
}
switch t.ActionType {
case tasks.ActionInstall:
output, err = pm.installPackages(ctx, t, managementCmds)
return
case tasks.ActionUninstall:
output, err = pm.uninstallPackages(ctx, t, managementCmds)
return
case tasks.ActionUpdate:
output, err = pm.updatePackages(ctx, t, managementCmds)
return
default:
err = fmt.Errorf("unknown action type '%v' for task %s", t.ActionType, t.TypeName)
return
}
}
func (pm PackageTaskManager) installPackages(ctx context.Context, t *tasks.PkgTask, mngtCmds *ManagementCmds) (output string, err error) {
logrus.Debugf("will install packages by executing %s", conv.ConvertSourceToJSONStrIfPossible(mngtCmds.InstallCmds))
output, err = pm.run(ctx, t, mngtCmds.InstallCmds...)
return
}
func (pm PackageTaskManager) uninstallPackages(ctx context.Context, t *tasks.PkgTask, mngtCmds *ManagementCmds) (output string, err error) {
logrus.Debugf("will uninstall packages by executing %s", conv.ConvertSourceToJSONStrIfPossible(mngtCmds.UninstallCmds))
output, err = pm.run(ctx, t, mngtCmds.UninstallCmds...)
return
}
func (pm PackageTaskManager) updatePackages(ctx context.Context, t *tasks.PkgTask, mngtCmds *ManagementCmds) (output string, err error) {
logrus.Debugf("will upgrade packages by executing %s", conv.ConvertSourceToJSONStrIfPossible(mngtCmds.UpgradeCmds))
output, err = pm.run(ctx, t, mngtCmds.UpgradeCmds...)
return
}
func (pm PackageTaskManager) updatePkgManagerIfNeeded(
ctx context.Context,
t *tasks.PkgTask,
mngtCmds *ManagementCmds,
) (output string, err error) {
if !t.ShouldRefresh {
return
}
logrus.Debugf("will update package manager: %s", mngtCmds.UpgradeCmd)
output, err = pm.run(ctx, t, mngtCmds.UpgradeCmd)
return
}
func (pm PackageTaskManager) run(ctx context.Context, t *tasks.PkgTask, rawCmds ...string) (output string, err error) {
var stdoutBuf, stderrBuf bytes.Buffer
execCtx := &exec.Context{
Ctx: ctx,
StdoutWriter: &stdoutBuf,
StderrWriter: &stderrBuf,
Path: t.Path,
Cmds: rawCmds,
Shell: t.Shell,
}
err = pm.Runner.Run(execCtx)
if err == nil {
logrus.Debugf("Cmds %s success", conv.ConvertSourceToJSONStrIfPossible(rawCmds))
}
logrus.Debugf(
"stdOut: %s, stdErr: %s",
stderrBuf.String(),
stdoutBuf.String(),
)
output = stderrBuf.String() + stdoutBuf.String()
return
}