cbcbe0da2e
Currently the rkt driver does not expose a DriverNetwork instance after starting the container, which means that address_mode = 'driver' does not work. To get the container network information, we can call `rkt status` on the UUID of the container and grab the container IP from there. For the port map, we need to grab the pod manifest as it will tell us which ports the container exposes. We then cross-reference the configured port name with the container port names, and use that to create a correct port mapping. To avoid doing a (bad) reimplementation of the appc schema(which rkt uses for its manifest) and rkt apis, we pull those in as vendored dependencies. The versions used are the same ones that rkt use in their glide dependency configuration for version 1.28.0.
149 lines
4.6 KiB
Go
149 lines
4.6 KiB
Go
package pflag
|
|
|
|
import (
|
|
"fmt"
|
|
"io"
|
|
"net"
|
|
"strings"
|
|
)
|
|
|
|
// -- ipSlice Value
|
|
type ipSliceValue struct {
|
|
value *[]net.IP
|
|
changed bool
|
|
}
|
|
|
|
func newIPSliceValue(val []net.IP, p *[]net.IP) *ipSliceValue {
|
|
ipsv := new(ipSliceValue)
|
|
ipsv.value = p
|
|
*ipsv.value = val
|
|
return ipsv
|
|
}
|
|
|
|
// Set converts, and assigns, the comma-separated IP argument string representation as the []net.IP value of this flag.
|
|
// If Set is called on a flag that already has a []net.IP assigned, the newly converted values will be appended.
|
|
func (s *ipSliceValue) Set(val string) error {
|
|
|
|
// remove all quote characters
|
|
rmQuote := strings.NewReplacer(`"`, "", `'`, "", "`", "")
|
|
|
|
// read flag arguments with CSV parser
|
|
ipStrSlice, err := readAsCSV(rmQuote.Replace(val))
|
|
if err != nil && err != io.EOF {
|
|
return err
|
|
}
|
|
|
|
// parse ip values into slice
|
|
out := make([]net.IP, 0, len(ipStrSlice))
|
|
for _, ipStr := range ipStrSlice {
|
|
ip := net.ParseIP(strings.TrimSpace(ipStr))
|
|
if ip == nil {
|
|
return fmt.Errorf("invalid string being converted to IP address: %s", ipStr)
|
|
}
|
|
out = append(out, ip)
|
|
}
|
|
|
|
if !s.changed {
|
|
*s.value = out
|
|
} else {
|
|
*s.value = append(*s.value, out...)
|
|
}
|
|
|
|
s.changed = true
|
|
|
|
return nil
|
|
}
|
|
|
|
// Type returns a string that uniquely represents this flag's type.
|
|
func (s *ipSliceValue) Type() string {
|
|
return "ipSlice"
|
|
}
|
|
|
|
// String defines a "native" format for this net.IP slice flag value.
|
|
func (s *ipSliceValue) String() string {
|
|
|
|
ipStrSlice := make([]string, len(*s.value))
|
|
for i, ip := range *s.value {
|
|
ipStrSlice[i] = ip.String()
|
|
}
|
|
|
|
out, _ := writeAsCSV(ipStrSlice)
|
|
|
|
return "[" + out + "]"
|
|
}
|
|
|
|
func ipSliceConv(val string) (interface{}, error) {
|
|
val = strings.Trim(val, "[]")
|
|
// Emtpy string would cause a slice with one (empty) entry
|
|
if len(val) == 0 {
|
|
return []net.IP{}, nil
|
|
}
|
|
ss := strings.Split(val, ",")
|
|
out := make([]net.IP, len(ss))
|
|
for i, sval := range ss {
|
|
ip := net.ParseIP(strings.TrimSpace(sval))
|
|
if ip == nil {
|
|
return nil, fmt.Errorf("invalid string being converted to IP address: %s", sval)
|
|
}
|
|
out[i] = ip
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
// GetIPSlice returns the []net.IP value of a flag with the given name
|
|
func (f *FlagSet) GetIPSlice(name string) ([]net.IP, error) {
|
|
val, err := f.getFlagType(name, "ipSlice", ipSliceConv)
|
|
if err != nil {
|
|
return []net.IP{}, err
|
|
}
|
|
return val.([]net.IP), nil
|
|
}
|
|
|
|
// IPSliceVar defines a ipSlice flag with specified name, default value, and usage string.
|
|
// The argument p points to a []net.IP variable in which to store the value of the flag.
|
|
func (f *FlagSet) IPSliceVar(p *[]net.IP, name string, value []net.IP, usage string) {
|
|
f.VarP(newIPSliceValue(value, p), name, "", usage)
|
|
}
|
|
|
|
// IPSliceVarP is like IPSliceVar, but accepts a shorthand letter that can be used after a single dash.
|
|
func (f *FlagSet) IPSliceVarP(p *[]net.IP, name, shorthand string, value []net.IP, usage string) {
|
|
f.VarP(newIPSliceValue(value, p), name, shorthand, usage)
|
|
}
|
|
|
|
// IPSliceVar defines a []net.IP flag with specified name, default value, and usage string.
|
|
// The argument p points to a []net.IP variable in which to store the value of the flag.
|
|
func IPSliceVar(p *[]net.IP, name string, value []net.IP, usage string) {
|
|
CommandLine.VarP(newIPSliceValue(value, p), name, "", usage)
|
|
}
|
|
|
|
// IPSliceVarP is like IPSliceVar, but accepts a shorthand letter that can be used after a single dash.
|
|
func IPSliceVarP(p *[]net.IP, name, shorthand string, value []net.IP, usage string) {
|
|
CommandLine.VarP(newIPSliceValue(value, p), name, shorthand, usage)
|
|
}
|
|
|
|
// IPSlice defines a []net.IP flag with specified name, default value, and usage string.
|
|
// The return value is the address of a []net.IP variable that stores the value of that flag.
|
|
func (f *FlagSet) IPSlice(name string, value []net.IP, usage string) *[]net.IP {
|
|
p := []net.IP{}
|
|
f.IPSliceVarP(&p, name, "", value, usage)
|
|
return &p
|
|
}
|
|
|
|
// IPSliceP is like IPSlice, but accepts a shorthand letter that can be used after a single dash.
|
|
func (f *FlagSet) IPSliceP(name, shorthand string, value []net.IP, usage string) *[]net.IP {
|
|
p := []net.IP{}
|
|
f.IPSliceVarP(&p, name, shorthand, value, usage)
|
|
return &p
|
|
}
|
|
|
|
// IPSlice defines a []net.IP flag with specified name, default value, and usage string.
|
|
// The return value is the address of a []net.IP variable that stores the value of the flag.
|
|
func IPSlice(name string, value []net.IP, usage string) *[]net.IP {
|
|
return CommandLine.IPSliceP(name, "", value, usage)
|
|
}
|
|
|
|
// IPSliceP is like IPSlice, but accepts a shorthand letter that can be used after a single dash.
|
|
func IPSliceP(name, shorthand string, value []net.IP, usage string) *[]net.IP {
|
|
return CommandLine.IPSliceP(name, shorthand, value, usage)
|
|
}
|