forked from openshift/origin
-
Notifications
You must be signed in to change notification settings - Fork 0
/
expose.go
221 lines (197 loc) · 6.93 KB
/
expose.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
package cmd
import (
"fmt"
"io"
"strings"
"github.com/spf13/cobra"
kapi "k8s.io/kubernetes/pkg/api"
kcmd "k8s.io/kubernetes/pkg/kubectl/cmd"
kcmdutil "k8s.io/kubernetes/pkg/kubectl/cmd/util"
"k8s.io/kubernetes/pkg/kubectl/resource"
"github.com/openshift/origin/pkg/cmd/util/clientcmd"
)
const (
exposeLong = `
Expose containers internally as services or externally via routes
There is also the ability to expose a deployment configuration, replication controller, service, or pod
as a new service on a specified port. If no labels are specified, the new object will re-use the
labels from the object it exposes.`
exposeExample = ` # Create a route based on service nginx. The new route will re-use nginx's labels
$ %[1]s expose service nginx
# Create a route and specify your own label and route name
$ %[1]s expose service nginx -l name=myroute --name=fromdowntown
# Create a route and specify a hostname
$ %[1]s expose service nginx --hostname=www.example.com
# Expose a deployment configuration as a service and use the specified port
$ %[1]s expose dc ruby-hello-world --port=8080
# Expose a service as a route in the specified path
$ %[1]s expose service nginx --path=/nginx`
)
// NewCmdExpose is a wrapper for the Kubernetes cli expose command
func NewCmdExpose(fullName string, f *clientcmd.Factory, out io.Writer) *cobra.Command {
cmd := kcmd.NewCmdExposeService(f.Factory, out)
cmd.Short = "Expose a replicated application as a service or route"
cmd.Long = exposeLong
cmd.Example = fmt.Sprintf(exposeExample, fullName)
// Default generator to an empty string so we can get more flexibility
// when setting defaults based on input resources
cmd.Flags().Set("generator", "")
cmd.Flag("generator").Usage = "The name of the API generator to use."
cmd.Flag("generator").DefValue = ""
// Default protocol to an empty string so we can get more flexibility
// when validating the use of it (invalid for routes)
cmd.Flags().Set("protocol", "")
cmd.Flag("protocol").DefValue = ""
cmd.Flag("protocol").Changed = false
defRun := cmd.Run
cmd.Run = func(cmd *cobra.Command, args []string) {
err := validate(cmd, f, args)
kcmdutil.CheckErr(err)
defRun(cmd, args)
}
cmd.Flags().String("hostname", "", "Set a hostname for the new route")
cmd.Flags().String("path", "", "Set a path for the new route")
return cmd
}
// validate adds one layer of validation prior to calling the upstream
// expose command.
func validate(cmd *cobra.Command, f *clientcmd.Factory, args []string) error {
namespace, enforceNamespace, err := f.DefaultNamespace()
if err != nil {
return err
}
_, kc, err := f.Clients()
if err != nil {
return err
}
mapper, typer := f.Object()
r := resource.NewBuilder(mapper, typer, resource.ClientMapperFunc(f.ClientForMapping), kapi.Codecs.UniversalDecoder()).
ContinueOnError().
NamespaceParam(namespace).DefaultNamespace().
FilenameParam(enforceNamespace, kcmdutil.GetFlagStringSlice(cmd, "filename")...).
ResourceTypeOrNameArgs(false, args...).
Flatten().
Do()
infos, err := r.Infos()
if err != nil {
return err
}
if len(infos) > 1 {
return fmt.Errorf("multiple resources provided: %v", args)
}
info := infos[0]
mapping := info.ResourceMapping()
generator := kcmdutil.GetFlagString(cmd, "generator")
switch mapping.GroupVersionKind.GroupKind() {
case kapi.Kind("Service"):
switch generator {
case "service/v1", "service/v2":
// Set default protocol back for generating services
if len(kcmdutil.GetFlagString(cmd, "protocol")) == 0 {
cmd.Flags().Set("protocol", "TCP")
}
return validateFlags(cmd, generator)
case "":
// Default exposing services as a route
generator = "route/v1"
cmd.Flags().Set("generator", generator)
fallthrough
case "route/v1":
// We need to validate services exposed as routes
if err := validateFlags(cmd, generator); err != nil {
return err
}
svc, err := kc.Services(info.Namespace).Get(info.Name)
if err != nil {
return err
}
supportsTCP := false
for _, port := range svc.Spec.Ports {
if port.Protocol == kapi.ProtocolTCP {
if len(port.Name) > 0 {
// Pass service port name as the route target port, if it is named
cmd.Flags().Set("target-port", port.Name)
}
supportsTCP = true
break
}
}
if !supportsTCP {
return fmt.Errorf("service %q doesn't support TCP", info.Name)
}
}
default:
switch generator {
case "route/v1":
return fmt.Errorf("cannot expose a %s as a route", mapping.GroupVersionKind.Kind)
case "":
// Default exposing everything except services as a service
generator = "service/v2"
cmd.Flags().Set("generator", generator)
fallthrough
case "service/v1", "service/v2":
// Set default protocol back for generating services
if len(kcmdutil.GetFlagString(cmd, "protocol")) == 0 {
cmd.Flags().Set("protocol", "TCP")
}
return validateFlags(cmd, generator)
}
}
return nil
}
// validateFlags filters out flags that are not supposed to be used
// when exposing a resource; depends on the provided generator
func validateFlags(cmd *cobra.Command, generator string) error {
invalidFlags := []string{}
switch generator {
case "service/v1", "service/v2":
if len(kcmdutil.GetFlagString(cmd, "hostname")) != 0 {
invalidFlags = append(invalidFlags, "--hostname")
}
if len(kcmdutil.GetFlagString(cmd, "path")) != 0 {
invalidFlags = append(invalidFlags, "--path")
}
case "route/v1":
if len(kcmdutil.GetFlagString(cmd, "protocol")) != 0 {
invalidFlags = append(invalidFlags, "--protocol")
}
if len(kcmdutil.GetFlagString(cmd, "type")) != 0 {
invalidFlags = append(invalidFlags, "--type")
}
if len(kcmdutil.GetFlagString(cmd, "selector")) != 0 {
invalidFlags = append(invalidFlags, "--selector")
}
if len(kcmdutil.GetFlagString(cmd, "container-port")) != 0 {
invalidFlags = append(invalidFlags, "--container-port")
}
if len(kcmdutil.GetFlagString(cmd, "target-port")) != 0 {
invalidFlags = append(invalidFlags, "--target-port")
}
if len(kcmdutil.GetFlagString(cmd, "external-ip")) != 0 {
invalidFlags = append(invalidFlags, "--external-ip")
}
if len(kcmdutil.GetFlagString(cmd, "port")) != 0 {
invalidFlags = append(invalidFlags, "--port")
}
if len(kcmdutil.GetFlagString(cmd, "load-balancer-ip")) != 0 {
invalidFlags = append(invalidFlags, "--load-balancer-ip")
}
if len(kcmdutil.GetFlagString(cmd, "session-affinity")) != 0 {
invalidFlags = append(invalidFlags, "--session-affinity")
}
if kcmdutil.GetFlagBool(cmd, "create-external-load-balancer") {
invalidFlags = append(invalidFlags, "--create-external-load-balancer")
}
}
msg := ""
switch len(invalidFlags) {
case 0:
return nil
case 1:
msg = invalidFlags[0]
default:
commaSeparated, last := invalidFlags[:len(invalidFlags)-1], invalidFlags[len(invalidFlags)-1]
msg = fmt.Sprintf("%s or %s", strings.Join(commaSeparated, ", "), last)
}
return fmt.Errorf("cannot use %s when generating a %s", msg, strings.Split(generator, "/")[0])
}