代码拉取完成,页面将自动刷新
/*
Copyright 2015 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 hostport
import (
"fmt"
log "github.com/golang/glog"
mesos "github.com/mesos/mesos-go/mesosproto"
"k8s.io/kubernetes/contrib/mesos/pkg/scheduler/meta"
"k8s.io/kubernetes/contrib/mesos/pkg/scheduler/resources"
"k8s.io/kubernetes/pkg/api"
)
// Objects implementing the Mapper interface generate port mappings
// from k8s container ports to ports offered by mesos
type Mapper interface {
// Map maps the given pod and the given mesos offer and returns a
// slice of port mappings or an error if the mapping failed
Map(pod *api.Pod, roles []string, offer *mesos.Offer) ([]Mapping, error)
}
// MapperFunc is a function adapter to the Mapper interface
type MapperFunc func(*api.Pod, []string, *mesos.Offer) ([]Mapping, error)
// Map calls f(t, offer)
func (f MapperFunc) Map(pod *api.Pod, roles []string, offer *mesos.Offer) ([]Mapping, error) {
return f(pod, roles, offer)
}
// A Mapping represents the mapping between k8s container ports
// ports offered by mesos. It references the k8s' container and port
// and specifies the offered mesos port and the offered port's role
type Mapping struct {
ContainerIdx int // index of the container in the pod spec
PortIdx int // index of the port in a container's port spec
OfferPort uint64 // the port offered by mesos
Role string // the role asssociated with the offered port
}
type PortAllocationError struct {
PodID string
Ports []uint64
}
func (err *PortAllocationError) Error() string {
return fmt.Sprintf("Could not schedule pod %s: %d port(s) could not be allocated", err.PodID, len(err.Ports))
}
type DuplicateError struct {
m1, m2 Mapping
}
func (err *DuplicateError) Error() string {
return fmt.Sprintf(
"Host port %d is specified for container %d, pod %d and container %d, pod %d",
err.m1.OfferPort, err.m1.ContainerIdx, err.m1.PortIdx, err.m2.ContainerIdx, err.m2.PortIdx)
}
// WildcardMapper maps k8s wildcard ports (hostPort == 0) to any available offer port
func WildcardMapper(pod *api.Pod, roles []string, offer *mesos.Offer) ([]Mapping, error) {
mapping, err := FixedMapper(pod, roles, offer)
if err != nil {
return nil, err
}
taken := make(map[uint64]struct{})
for _, entry := range mapping {
taken[entry.OfferPort] = struct{}{}
}
wildports := []Mapping{}
for i, container := range pod.Spec.Containers {
for pi, port := range container.Ports {
if port.HostPort == 0 {
wildports = append(wildports, Mapping{
ContainerIdx: i,
PortIdx: pi,
})
}
}
}
remaining := len(wildports)
resources.ForeachPortsRange(offer.GetResources(), roles, func(bp, ep uint64, role string) {
log.V(3).Infof("Searching for wildcard port in range {%d:%d}", bp, ep)
for i := range wildports {
if wildports[i].OfferPort != 0 {
continue
}
for port := bp; port <= ep && remaining > 0; port++ {
if _, inuse := taken[port]; inuse {
continue
}
wildports[i].OfferPort = port
wildports[i].Role = resources.CanonicalRole(role)
mapping = append(mapping, wildports[i])
remaining--
taken[port] = struct{}{}
break
}
}
})
if remaining > 0 {
err := &PortAllocationError{
PodID: pod.Namespace + "/" + pod.Name,
}
// it doesn't make sense to include a port list here because they were all zero (wildcards)
return nil, err
}
return mapping, nil
}
// FixedMapper maps k8s host ports to offered ports ignoring hostPorts == 0 (remaining pod-private)
func FixedMapper(pod *api.Pod, roles []string, offer *mesos.Offer) ([]Mapping, error) {
requiredPorts := make(map[uint64]Mapping)
mapping := []Mapping{}
for i, container := range pod.Spec.Containers {
// strip all port==0 from this array; k8s already knows what to do with zero-
// ports (it does not create 'port bindings' on the minion-host); we need to
// remove the wildcards from this array since they don't consume host resources
for pi, port := range container.Ports {
if port.HostPort == 0 {
continue // ignore
}
m := Mapping{
ContainerIdx: i,
PortIdx: pi,
OfferPort: uint64(port.HostPort),
}
if entry, inuse := requiredPorts[uint64(port.HostPort)]; inuse {
return nil, &DuplicateError{entry, m}
}
requiredPorts[uint64(port.HostPort)] = m
}
}
resources.ForeachPortsRange(offer.GetResources(), roles, func(bp, ep uint64, role string) {
for port := range requiredPorts {
log.V(3).Infof("evaluating port range {%d:%d} %d", bp, ep, port)
if (bp <= port) && (port <= ep) {
m := requiredPorts[port]
m.Role = resources.CanonicalRole(role)
mapping = append(mapping, m)
delete(requiredPorts, port)
}
}
})
unsatisfiedPorts := len(requiredPorts)
if unsatisfiedPorts > 0 {
err := &PortAllocationError{
PodID: pod.Namespace + "/" + pod.Name,
}
for p := range requiredPorts {
err.Ports = append(err.Ports, p)
}
return nil, err
}
return mapping, nil
}
type Strategy string
const (
// maps a Container.HostPort to the same exact offered host port, ignores .HostPort = 0
StrategyFixed = Strategy("fixed")
// same as MappingFixed, except that .HostPort of 0 are mapped to any port offered
StrategyWildcard = Strategy("wildcard")
)
var validStrategies = map[Strategy]MapperFunc{
StrategyFixed: MapperFunc(FixedMapper),
StrategyWildcard: MapperFunc(WildcardMapper),
}
// NewMapper returns a new mapper based on the port mapping key value
func (defaultStrategy Strategy) NewMapper(pod *api.Pod) Mapper {
strategy, ok := pod.Labels[meta.PortMappingKey]
if ok {
f, ok := validStrategies[Strategy(strategy)]
if ok {
return f
}
log.Warningf("invalid port mapping strategy %q, reverting to default %q", strategy, defaultStrategy)
}
f, ok := validStrategies[defaultStrategy]
if ok {
return f
}
panic("scheduler is misconfigured, unrecognized default strategy \"" + defaultStrategy + "\"")
}
此处可能存在不合适展示的内容,页面不予展示。您可通过相关编辑功能自查并修改。
如您确认内容无涉及 不当用语 / 纯广告导流 / 暴力 / 低俗色情 / 侵权 / 盗版 / 虚假 / 无价值内容或违法国家有关法律法规的内容,可点击提交进行申诉,我们将尽快为您处理。