github/kubernetes
4
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge pull request #15461 from kargakis/relax-exposing-multiport-objects

Browse Source 
expose: Enable exposing multiport objects
This commit is contained in:
Jerzy Szczepkowski
2015-10-27 10:25:54 +01:00
parent 6b72e1d8e4 7d0e691520
commit bbee6cfcd7
8 changed files with 237 additions and 37 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
pkg/kubectl/cmd/cmd_test.go
View File

@@ -235,6 +235,8 @@ func NewAPIFactory() (*cmdutil.Factory, *testFactory, runtime.Codec) {
}
rf := cmdutil.NewFactory(nil)
f.PodSelectorForObject = rf.PodSelectorForObject
f.PortsForObject = rf.PortsForObject
f.LabelsForObject = rf.LabelsForObject
f.CanBeExposed = rf.CanBeExposed
return f, t, testapi.Default.Codec()
}

12
pkg/kubectl/cmd/expose.go
View File

@@ -19,6 +19,7 @@ package cmd
import (
"fmt"
"io"
"strings"
"github.com/spf13/cobra"
@@ -35,11 +36,12 @@ type ExposeOptions struct {
}
const (
expose_long = `Take a replication controller, service or pod and expose it as a new Kubernetes Service.
expose_long = `Take a replication controller, service, or pod and expose it as a new Kubernetes service.
Looks up a replication controller, service or pod by name and uses the selector for that resource as the
selector for a new Service on the specified port. If no labels are specified, the new service will
re-use the labels from the resource it exposes.`
Looks up a replication controller, service, or pod by name and uses the selector for that resource as the
selector for a new service on the specified port. Note that if no port is specified via --port and the
exposed resource has multiple ports, all will be re-used by the new service. Also if no labels are specified,
the new service will re-use the labels from the resource it exposes.`
expose_example = `# Create a service for a replicated nginx, which serves on port 80 and connects to the containers on port 8000.
$ kubectl expose rc nginx --port=80 --target-port=8000
@@ -163,7 +165,7 @@ func RunExpose(f *cmdutil.Factory, out io.Writer, cmd *cobra.Command, args []str
case 1:
params["port"] = ports[0]
default:
return cmdutil.UsageError(cmd, fmt.Sprintf("multiple ports to choose from: %v, please explicitly specify a port using the --port flag.", ports))
params["ports"] = strings.Join(ports, ",")
}
}
if kubectl.IsZero(params["labels"]) {

48
pkg/kubectl/cmd/expose_test.go
View File

@@ -286,6 +286,54 @@ func TestRunExposeService(t *testing.T) {
expected: "service \"a-name-that-is-toooo-big\" exposed",
status: 200,
},
{
name: "expose-multiport-object",
args: []string{"service", "foo"},
ns: "test",
calls: map[string]string{
"GET": "/namespaces/test/services/foo",
"POST": "/namespaces/test/services",
},
input: &api.Service{
ObjectMeta: api.ObjectMeta{Name: "foo", Namespace: "", Labels: map[string]string{"svc": "multiport"}},
Spec: api.ServiceSpec{
Ports: []api.ServicePort{
{
Protocol: api.ProtocolTCP,
Port: 80,
TargetPort: util.NewIntOrStringFromInt(80),
},
{
Protocol: api.ProtocolTCP,
Port: 443,
TargetPort: util.NewIntOrStringFromInt(443),
},
},
},
},
flags: map[string]string{"selector": "svc=fromfoo", "generator": "service/v2", "name": "fromfoo", "dry-run": "true"},
output: &api.Service{
ObjectMeta: api.ObjectMeta{Name: "fromfoo", Namespace: "", Labels: map[string]string{"svc": "multiport"}},
Spec: api.ServiceSpec{
Ports: []api.ServicePort{
{
Name: "port-1",
Protocol: api.ProtocolTCP,
Port: 80,
TargetPort: util.NewIntOrStringFromInt(80),
},
{
Name: "port-2",
Protocol: api.ProtocolTCP,
Port: 443,
TargetPort: util.NewIntOrStringFromInt(443),
},
},
Selector: map[string]string{"svc": "fromfoo"},
},
},
status: 200,
},
}
for _, test := range tests {

78
pkg/kubectl/service.go
View File

@@ -19,6 +19,7 @@ package kubectl
import (
"fmt"
"strconv"
"strings"
"k8s.io/kubernetes/pkg/api"
"k8s.io/kubernetes/pkg/runtime"
@@ -52,7 +53,12 @@ func paramNames() []GeneratorParam {
{"default-name", true},
{"name", false},
{"selector", true},
{"port", true},
// port will be used if a user specifies --port OR the exposed object
// has one port
{"port", false},
// ports will be used iff a user doesn't specify --port AND the
// exposed object has multiple ports
{"ports", false},
{"labels", false},
{"external-ip", false},
{"create-external-load-balancer", false},
@@ -100,19 +106,41 @@ func generate(genericParams map[string]interface{}) (runtime.Object, error) {
return nil, fmt.Errorf("'name' is a required parameter.")
}
}
portString, found := params["port"]
if !found {
return nil, fmt.Errorf("'port' is a required parameter.")
}
port, err := strconv.Atoi(portString)
if err != nil {
return nil, err
}
ports := []api.ServicePort{}
servicePortName, found := params["port-name"]
if !found {
// Leave the port unnamed.
servicePortName = ""
}
// ports takes precedence over port since it will be
// specified only when the user hasn't specified a port
// via --port and the exposed object has multiple ports.
var portString string
if portString, found = params["ports"]; !found {
portString, found = params["port"]
if !found {
return nil, fmt.Errorf("'port' is a required parameter.")
}
}
portStringSlice := strings.Split(portString, ",")
for i, stillPortString := range portStringSlice {
port, err := strconv.Atoi(stillPortString)
if err != nil {
return nil, err
}
name := servicePortName
// If we are going to assign multiple ports to a service, we need to
// generate a different name for each one.
if len(portStringSlice) > 1 {
name = fmt.Sprintf("port-%d", i+1)
}
ports = append(ports, api.ServicePort{
Name: name,
Port: port,
Protocol: api.Protocol(params["protocol"]),
})
}
service := api.Service{
ObjectMeta: api.ObjectMeta{
Name: name,
@@ -120,27 +148,31 @@ func generate(genericParams map[string]interface{}) (runtime.Object, error) {
},
Spec: api.ServiceSpec{
Selector: selector,
Ports: []api.ServicePort{
{
Name: servicePortName,
Port: port,
Protocol: api.Protocol(params["protocol"]),
},
},
Ports: ports,
},
}
targetPort, found := params["target-port"]
targetPortString, found := params["target-port"]
if !found {
targetPort, found = params["container-port"]
targetPortString, found = params["container-port"]
}
if found && len(targetPort) > 0 {
if portNum, err := strconv.Atoi(targetPort); err != nil {
service.Spec.Ports[0].TargetPort = util.NewIntOrStringFromString(targetPort)
if found && len(targetPortString) > 0 {
var targetPort util.IntOrString
if portNum, err := strconv.Atoi(targetPortString); err != nil {
targetPort = util.NewIntOrStringFromString(targetPortString)
} else {
service.Spec.Ports[0].TargetPort = util.NewIntOrStringFromInt(portNum)
targetPort = util.NewIntOrStringFromInt(portNum)
}
// Use the same target-port for every port
for i := range service.Spec.Ports {
service.Spec.Ports[i].TargetPort = targetPort
}
} else {
service.Spec.Ports[0].TargetPort = util.NewIntOrStringFromInt(port)
// If --target-port or --container-port haven't been specified, this
// should be the same as Port
for i := range service.Spec.Ports {
port := service.Spec.Ports[i].Port
service.Spec.Ports[i].TargetPort = util.NewIntOrStringFromInt(port)
}
}
if params["create-external-load-balancer"] == "true" {
service.Spec.Type = api.ServiceTypeLoadBalancer

101
pkg/kubectl/service_test.go
View File

@@ -303,6 +303,107 @@ func TestGenerateService(t *testing.T) {
},
},
},
{
generator: ServiceGeneratorV1{},
params: map[string]interface{}{
"selector": "foo=bar",
"name": "test",
"ports": "80,443",
"protocol": "TCP",
"container-port": "foobar",
},
expected: api.Service{
ObjectMeta: api.ObjectMeta{
Name: "test",
},
Spec: api.ServiceSpec{
Selector: map[string]string{
"foo": "bar",
},
Ports: []api.ServicePort{
{
Name: "port-1",
Port: 80,
Protocol: api.ProtocolTCP,
TargetPort: util.NewIntOrStringFromString("foobar"),
},
{
Name: "port-2",
Port: 443,
Protocol: api.ProtocolTCP,
TargetPort: util.NewIntOrStringFromString("foobar"),
},
},
},
},
},
{
generator: ServiceGeneratorV2{},
params: map[string]interface{}{
"selector": "foo=bar",
"name": "test",
"ports": "80,443",
"protocol": "UDP",
"target-port": "1234",
},
expected: api.Service{
ObjectMeta: api.ObjectMeta{
Name: "test",
},
Spec: api.ServiceSpec{
Selector: map[string]string{
"foo": "bar",
},
Ports: []api.ServicePort{
{
Name: "port-1",
Port: 80,
Protocol: api.ProtocolUDP,
TargetPort: util.NewIntOrStringFromInt(1234),
},
{
Name: "port-2",
Port: 443,
Protocol: api.ProtocolUDP,
TargetPort: util.NewIntOrStringFromInt(1234),
},
},
},
},
},
{
generator: ServiceGeneratorV2{},
params: map[string]interface{}{
"selector": "foo=bar",
"name": "test",
"ports": "80,443",
"protocol": "TCP",
},
expected: api.Service{
ObjectMeta: api.ObjectMeta{
Name: "test",
},
Spec: api.ServiceSpec{
Selector: map[string]string{
"foo": "bar",
},
Ports: []api.ServicePort{
{
Name: "port-1",
Port: 80,
Protocol: api.ProtocolTCP,
TargetPort: util.NewIntOrStringFromInt(80),
},
{
Name: "port-2",
Port: 443,
Protocol: api.ProtocolTCP,
TargetPort: util.NewIntOrStringFromInt(443),
},
},
},
},
},
}
for _, test := range tests {
obj, err := test.generator.Generate(test.params)