/
move.go
258 lines (225 loc) · 8.01 KB
/
move.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
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
// Copyright 2019 The Kubernetes Authors.
//
// 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 installation
import (
"io"
"io/ioutil"
"os"
"path/filepath"
"syscall"
"github.com/pkg/errors"
"k8s.io/klog"
"sigs.k8s.io/krew/internal/pathutil"
"sigs.k8s.io/krew/pkg/index"
)
type move struct {
from, to string
}
func findMoveTargets(fromDir, toDir string, fo index.FileOperation) ([]move, error) {
if fo.To != filepath.Clean(fo.To) {
return nil, errors.Errorf("the provided path is not clean, %q should be %q", fo.To, filepath.Clean(fo.To))
}
fromDir, err := filepath.Abs(fromDir)
if err != nil {
return nil, errors.Wrap(err, "could not get the relative path for the move src")
}
klog.V(4).Infof("Trying to move single file directly from=%q to=%q with file operation=%#v", fromDir, toDir, fo)
if m, ok, err := getDirectMove(fromDir, toDir, fo); err != nil {
return nil, errors.Wrap(err, "failed to detect single move operation")
} else if ok {
klog.V(3).Infof("Detected single move from file operation=%#v", fo)
return []move{m}, nil
}
klog.V(4).Infoln("Wasn't a single file, proceeding with Glob move")
newDir, err := filepath.Abs(filepath.Join(filepath.FromSlash(toDir), filepath.FromSlash(fo.To)))
if err != nil {
return nil, errors.Wrap(err, "could not get the relative path for the move dst")
}
gl, err := filepath.Glob(filepath.Join(filepath.FromSlash(fromDir), filepath.FromSlash(fo.From)))
if err != nil {
return nil, errors.Wrap(err, "could not get files using a glob string")
}
if len(gl) == 0 {
return nil, errors.Errorf("no files in the plugin archive matched the glob pattern=%s", fo.From)
}
moves := make([]move, 0, len(gl))
for _, v := range gl {
newPath := filepath.Join(newDir, filepath.Base(filepath.FromSlash(v)))
// Check secure path
m := move{from: v, to: newPath}
if !isMoveAllowed(fromDir, toDir, m) {
return nil, errors.Errorf("can't move, move target %v is not a subpath from=%q, to=%q", m, fromDir, toDir)
}
moves = append(moves, m)
}
return moves, nil
}
func getDirectMove(fromDir, toDir string, fo index.FileOperation) (move, bool, error) {
var m move
fromDir, err := filepath.Abs(fromDir)
if err != nil {
return m, false, errors.Wrap(err, "could not get the relative path for the move src")
}
toDir, err = filepath.Abs(toDir)
if err != nil {
return m, false, errors.Wrap(err, "could not get the relative path for the move src")
}
// Check is direct file (not a Glob)
fromFilePath := filepath.Clean(filepath.Join(fromDir, fo.From))
_, err = os.Stat(fromFilePath)
if err != nil {
return m, false, nil
}
// If target is empty use old file name.
if filepath.Clean(fo.To) == "." {
fo.To = filepath.Base(fromFilePath)
}
// Build new file name
toFilePath, err := filepath.Abs(filepath.Join(filepath.FromSlash(toDir), filepath.FromSlash(fo.To)))
if err != nil {
return m, false, errors.Wrap(err, "could not get the relative path for the move dst")
}
// Check sane path
m = move{from: fromFilePath, to: toFilePath}
if !isMoveAllowed(fromDir, toDir, m) {
return move{}, false, errors.Errorf("can't move, move target %v is out of bounds from=%q, to=%q", m, fromDir, toDir)
}
return m, true, nil
}
func isMoveAllowed(fromBase, toBase string, m move) bool {
_, okFrom := pathutil.IsSubPath(fromBase, m.from)
_, okTo := pathutil.IsSubPath(toBase, m.to)
return okFrom && okTo
}
func moveFiles(fromDir, toDir string, fo index.FileOperation) error {
klog.V(4).Infof("Finding move targets from %q to %q with file operation=%#v", fromDir, toDir, fo)
moves, err := findMoveTargets(fromDir, toDir, fo)
if err != nil {
return errors.Wrap(err, "could not find move targets")
}
for _, m := range moves {
klog.V(2).Infof("Move file from %q to %q", m.from, m.to)
if err := os.MkdirAll(filepath.Dir(m.to), 0755); err != nil {
return errors.Wrapf(err, "failed to create move path %q", filepath.Dir(m.to))
}
if err = renameOrCopy(m.from, m.to); err != nil {
return errors.Wrapf(err, "could not rename/copy file from %q to %q", m.from, m.to)
}
}
klog.V(4).Infoln("Move operations are complete")
return nil
}
func moveAllFiles(fromDir, toDir string, fos []index.FileOperation) error {
for _, fo := range fos {
if err := moveFiles(fromDir, toDir, fo); err != nil {
return errors.Wrap(err, "failed moving files")
}
}
return nil
}
// moveToInstallDir moves plugins from srcDir to dstDir (created in this method) with given FileOperation.
func moveToInstallDir(srcDir, installDir string, fos []index.FileOperation) error {
klog.V(4).Infof("Creating plugin installation directory %q", installDir)
if err := os.MkdirAll(installDir, 0755); err != nil {
return errors.Wrapf(err, "error creating installation directory at %q", installDir)
}
tmp, err := ioutil.TempDir("", "krew-temp-move")
klog.V(4).Infof("Creating temp plugin move operations dir %q", tmp)
if err != nil {
return errors.Wrap(err, "failed to find a temporary director")
}
defer os.RemoveAll(tmp)
if err = moveAllFiles(srcDir, tmp, fos); err != nil {
return errors.Wrap(err, "failed to move files")
}
klog.V(2).Infof("Move directory %q to %q", tmp, installDir)
if err = renameOrCopy(tmp, installDir); err != nil {
defer func() {
klog.V(3).Info("Cleaning up installation directory due to error during copying files")
os.Remove(installDir)
}()
return errors.Wrapf(err, "could not rename/copy directory %q to %q", tmp, installDir)
}
return nil
}
// renameOrCopy will try to rename a dir or file. If rename is not supported, a manual copy will be performed.
// Existing files at "to" will be deleted.
func renameOrCopy(from, to string) error {
// Try atomic rename (does not work cross partition).
fi, err := os.Stat(to)
if err != nil && !os.IsNotExist(err) {
return errors.Wrapf(err, "error checking move target dir %q", to)
}
if fi != nil && fi.IsDir() {
klog.V(4).Infof("There's already a directory at move target %q. deleting.", to)
if err := os.RemoveAll(to); err != nil {
return errors.Wrapf(err, "error cleaning up dir %q", to)
}
klog.V(4).Infof("Move target directory %q cleaned up", to)
}
err = os.Rename(from, to)
// Fallback for invalid cross-device link (errno:18).
if isCrossDeviceRenameErr(err) {
klog.V(2).Infof("Cross-device link error while copying, fallback to manual copy")
return errors.Wrap(copyTree(from, to), "failed to copy directory tree as a fallback")
}
return err
}
// copyTree copies files or directories, recursively.
func copyTree(from, to string) (err error) {
return filepath.Walk(from, func(path string, info os.FileInfo, err error) error {
if err != nil {
return err
}
newPath, _ := pathutil.ReplaceBase(path, from, to)
if info.IsDir() {
klog.V(4).Infof("Creating new dir %q", newPath)
err = os.MkdirAll(newPath, info.Mode())
} else {
klog.V(4).Infof("Copying file %q", newPath)
err = copyFile(path, newPath, info.Mode())
}
return err
})
}
func copyFile(source, dst string, mode os.FileMode) (err error) {
sf, err := os.Open(source)
if err != nil {
return err
}
defer sf.Close()
df, err := os.Create(dst)
if err != nil {
return err
}
defer df.Close()
_, err = io.Copy(df, sf)
if err != nil {
return err
}
return os.Chmod(dst, mode)
}
// isCrossDeviceRenameErr determines if a os.Rename error is due to cross-fs/drive/volume copying.
func isCrossDeviceRenameErr(err error) bool {
le, ok := err.(*os.LinkError)
if !ok {
return false
}
errno, ok := le.Err.(syscall.Errno)
if !ok {
return false
}
return (IsWindows() && errno == 17) || // syscall.ERROR_NOT_SAME_DEVICE
(!IsWindows() && errno == 18) // syscall.EXDEV
}