-
Notifications
You must be signed in to change notification settings - Fork 736
/
utils.go
143 lines (121 loc) · 4.12 KB
/
utils.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
/*
Copyright 2016 The Kubernetes Authors All rights reserved.
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 transformer
import (
"fmt"
"io/ioutil"
"os"
"strings"
log "github.com/Sirupsen/logrus"
"github.com/kubernetes-incubator/kompose/pkg/kobject"
"path/filepath"
"github.com/pkg/errors"
)
const Selector = "io.kompose.service"
// CreateOutFile creates the file to write to if --out is specified
func CreateOutFile(out string) (*os.File, error) {
var f *os.File
var err error
if len(out) != 0 {
f, err = os.Create(out)
if err != nil {
return nil, errors.Wrap(err, "error creating file, os.Create failed")
}
}
return f, nil
}
// ParseVolume parses a given volume, which might be [name:][host:]container[:access_mode]
func ParseVolume(volume string) (name, host, container, mode string, err error) {
separator := ":"
// Parse based on ":"
volumeStrings := strings.Split(volume, separator)
if len(volumeStrings) == 0 {
return
}
// Set name if existed
if !isPath(volumeStrings[0]) {
name = volumeStrings[0]
volumeStrings = volumeStrings[1:]
}
// Check if *anything* has been passed
if len(volumeStrings) == 0 {
err = fmt.Errorf("invalid volume format: %s", volume)
return
}
// Get the last ":" passed which is presumingly the "access mode"
possibleAccessMode := volumeStrings[len(volumeStrings)-1]
// Check to see if :Z or :z exists. We do not support SELinux relabeling at the moment.
// See https://github.com/kubernetes-incubator/kompose/issues/176
// Otherwise, check to see if "rw" or "ro" has been passed
if possibleAccessMode == "z" || possibleAccessMode == "Z" {
log.Warnf("Volume mount \"%s\" will be mounted without labeling support. :z or :Z not supported", volume)
mode = ""
volumeStrings = volumeStrings[:len(volumeStrings)-1]
} else if possibleAccessMode == "rw" || possibleAccessMode == "ro" {
mode = possibleAccessMode
volumeStrings = volumeStrings[:len(volumeStrings)-1]
}
// Check the volume format as well as host
container = volumeStrings[len(volumeStrings)-1]
volumeStrings = volumeStrings[:len(volumeStrings)-1]
if len(volumeStrings) == 1 {
host = volumeStrings[0]
}
if !isPath(container) || (len(host) > 0 && !isPath(host)) || len(volumeStrings) > 1 {
err = fmt.Errorf("invalid volume format: %s", volume)
return
}
return
}
func isPath(substring string) bool {
return strings.Contains(substring, "/")
}
// ConfigLabels configures label
func ConfigLabels(name string) map[string]string {
return map[string]string{Selector: name}
}
// ConfigAnnotations configures annotations
func ConfigAnnotations(service kobject.ServiceConfig) map[string]string {
annotations := map[string]string{}
for key, value := range service.Annotations {
annotations[key] = value
}
return annotations
}
// Print either prints to stdout or to file/s
func Print(name, path string, trailing string, data []byte, toStdout, generateJSON bool, f *os.File) (string, error) {
file := ""
if generateJSON {
file = fmt.Sprintf("%s-%s.json", name, trailing)
} else {
file = fmt.Sprintf("%s-%s.yaml", name, trailing)
}
if toStdout {
fmt.Fprintf(os.Stdout, "%s\n", string(data))
return "", nil
} else if f != nil {
// Write all content to a single file f
if _, err := f.WriteString(fmt.Sprintf("%s\n", string(data))); err != nil {
return "", errors.Wrap(err, "f.WriteString failed, Failed to write %s to file: "+trailing)
}
f.Sync()
} else {
// Write content separately to each file
file = filepath.Join(path, file)
if err := ioutil.WriteFile(file, []byte(data), 0644); err != nil {
return "", errors.Wrap(err, "Failed to write %s: "+trailing)
}
log.Printf("file %q created", file)
}
return file, nil
}