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
|
/*
* Copyright 2018 Intel Corporation, Inc
*
* 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 rb
import (
"archive/tar"
"compress/gzip"
"github.com/onap/multicloud-k8s/src/k8splugin/internal/utils"
pkgerrors "github.com/pkg/errors"
"io"
"io/ioutil"
"os"
"path/filepath"
)
func isTarGz(r io.Reader) error {
//Check if it is a valid gz
gzf, err := gzip.NewReader(r)
if err != nil {
return pkgerrors.Wrap(err, "Invalid gzip format")
}
//Check if it is a valid tar file
//Unfortunately this can only be done by inspecting all the tar contents
tarR := tar.NewReader(gzf)
first := true
for true {
header, err := tarR.Next()
if err == io.EOF {
//Check if we have just a gzip file without a tar archive inside
if first {
return pkgerrors.New("Empty or non-existant Tar file found")
}
//End of archive
break
}
if err != nil {
return pkgerrors.Errorf("Error reading tar file %s", err.Error())
}
//Check if files are of type directory and regular file
if header.Typeflag != tar.TypeDir &&
header.Typeflag != tar.TypeReg {
return pkgerrors.Errorf("Unknown header in tar %s, %s",
header.Name, string(header.Typeflag))
}
first = false
}
return nil
}
//ExtractTarBall provides functionality to extract a tar.gz file
//into a temporary location for later use.
//It returns the path to the new location
func ExtractTarBall(r io.Reader) (string, error) {
//Check if it is a valid gz
gzf, err := gzip.NewReader(r)
if err != nil {
return "", pkgerrors.Wrap(err, "Invalid gzip format")
}
//Check if it is a valid tar file
//Unfortunately this can only be done by inspecting all the tar contents
tarR := tar.NewReader(gzf)
first := true
outDir, _ := ioutil.TempDir("", "k8s-ext-")
for true {
header, err := tarR.Next()
if err == io.EOF {
//Check if we have just a gzip file without a tar archive inside
if first {
return "", pkgerrors.New("Empty or non-existant Tar file found")
}
//End of archive
break
}
if err != nil {
return "", pkgerrors.Wrap(err, "Error reading tar file")
}
target := filepath.Join(outDir, header.Name)
switch header.Typeflag {
case tar.TypeDir:
if _, err := os.Stat(target); err != nil {
// Using 755 read, write, execute for owner
// groups and others get read and execute permissions
// on the folder.
if err := os.MkdirAll(target, 0755); err != nil {
return "", pkgerrors.Wrap(err, "Creating directory")
}
}
case tar.TypeReg:
if target == outDir { // Handle '.' substituted to '' entry
continue
}
err = utils.EnsureDirectory(target)
if err != nil {
return "", pkgerrors.Wrap(err, "Creating Directory")
}
f, err := os.OpenFile(target, os.O_CREATE|os.O_RDWR, os.FileMode(header.Mode))
if err != nil {
return "", pkgerrors.Wrap(err, "Creating file")
}
// copy over contents
if _, err := io.Copy(f, tarR); err != nil {
return "", pkgerrors.Wrap(err, "Copying file content")
}
// close for each file instead of a defer for all
// at the end of the function
f.Close()
}
first = false
}
return outDir, nil
}
|
