def startip_cmd(self):
if which("ifconfig") and self.alias:
if ':' in self.addr:
cmd = [
'ifconfig', self.ipdev, 'inet6', 'add',
'/'.join([self.addr, to_cidr(self.netmask)])
]
else:
cmd = [
'ifconfig', self.stacked_dev, self.addr, 'netmask',
to_dotted(self.netmask), 'up'
]
else:
cmd = [
Env.syspaths.ip, "addr", "add",
'/'.join([self.addr, to_cidr(self.netmask)]), "dev", self.ipdev
]
ret, out, err = self.vcall(cmd)
if ret != 0:
return ret, out, err
# ip activation may still be incomplete
# wait for activation, to avoid startapp scripts to fail binding their listeners
for i in range(5, 0, -1):
if utilities.ping.check_ping(self.addr, timeout=1, count=1):
return ret, out, err
self.log.error("timed out waiting for ip activation")
raise ex.Error
def is_up(self):
cmd = [
Env.syspaths.ipadm, "show-addr", "-p", "-o", "STATE,ADDR",
self.ipdev + '/' + self.ipdevext
]
out, err, ret = justcall(cmd)
if ret != 0:
# normal down state
return False
try:
state, addr = out.strip("\n").split(":")
except ValueError:
self.status_log(out)
return False
if state != "ok":
self.status_log("state: %s" % state)
return False
try:
_addr, _mask = addr.split("/")
except ValueError:
self.status_log(out)
return False
if _addr != self.addr:
self.status_log("wrong addr: %s" % addr)
return False
if self.netmask is None:
self.status_log("netmask not specified nor guessable")
elif _mask != to_cidr(self.netmask):
self.status_log("wrong netmask: %s, expected %s" %
(_mask, to_cidr(self.netmask)))
return True
return True
def _is_up(self, ifconfig):
intf = ifconfig.has_param("ipaddr", self.addr)
if intf is not None:
if isinstance(intf.ipaddr, list):
idx = intf.ipaddr.index(self.addr)
current_mask = to_cidr(intf.mask[idx])
else:
current_mask = to_cidr(intf.mask)
if self.netmask is None:
self.status_log("netmask is not set nor guessable")
elif current_mask != to_cidr(self.netmask):
self.status_log("current netmask %s, expected %s" %
(current_mask, to_cidr(self.netmask)))
ref_dev = intf.name.split(":")[0]
if self.type == "ip" and ref_dev != self.ipdev:
self.status_log("current dev %s, expected %s" %
(ref_dev, self.ipdev))
return True
intf = ifconfig.has_param("ip6addr", self.addr)
if intf is not None:
if isinstance(intf.ip6addr, list):
idx = intf.ip6addr.index(self.addr)
current_mask = to_cidr(intf.ip6mask[idx])
else:
current_mask = to_cidr(intf.ip6mask)
if current_mask != to_cidr(self.netmask):
self.status_log("current netmask %s, expected %s" %
(current_mask, to_cidr(self.netmask)))
ref_dev = intf.name.split(":")[0]
if self.type == "ip" and ref_dev != self.ipdev:
self.status_log("current dev %s, expected %s" %
(ref_dev, self.ipdev))
return True
return False
def get_sysidcfg_network_interfaces(self):
network_interfaces = []
for rid in self.get_encap_ip_rids():
ipdev = self.get_encap_conf(rid, 'ipdev')
try:
default_route = self.get_encap_conf(rid, 'gateway')
except (ex.RequiredOptNotFound, ex.OptNotFound):
default_route = None
try:
netmask_conf = self.get_encap_conf(rid, 'netmask')
except (ex.RequiredOptNotFound, ex.OptNotFound):
netmask_conf = None
if netmask_conf is None:
netmask = None
else:
netmask = cidr_to_dotted(to_cidr(netmask_conf))
ipname = self.get_encap_conf(rid, 'ipname')
addr = getaddr(ipname, True)
if len(network_interfaces) == 0:
network_interface = "network_interface=PRIMARY {primary hostname=%s\n" % self.name
network_interface += " default_route=%s\n" % default_route
else:
network_interface = "network_interface=%s {\n" % ipdev
network_interface += " ip_address=%s\n" % addr
if netmask:
network_interface += " netmask=%s\n" % netmask
network_interface += " protocol_ipv6=no}\n"
network_interfaces.append(network_interface)
return network_interfaces
def get_install_ipv4_interfaces(self):
"""
returns list of InstallIpv4Interface tha will be used to create sc_profile
"""
from .configuration_profile import InstallIpv4Interface
ipv4_interfaces = []
for rid in self.get_encap_ip_rids():
try:
ipdevext = self.get_encap_conf(rid, 'ipdevext')
except (ex.RequiredOptNotFound, ex.OptNotFound):
ipdevext = 'v4'
ipdev = self.get_encap_conf(rid, 'ipdev')
ipv4_name = '%s/%s' % (ipdev, ipdevext)
try:
default_route = self.get_encap_conf(rid, 'gateway')
except (ex.RequiredOptNotFound, ex.OptNotFound):
default_route = None
try:
netmask = to_cidr(self.get_encap_conf(rid, 'netmask'))
except (ex.RequiredOptNotFound, ex.OptNotFound):
continue
ipname = self.get_encap_conf(rid, 'ipname')
addr = getaddr(ipname, True)
ipv4_interface = InstallIpv4Interface(ipv4_name,
static_address='%s/%s' %
(addr, netmask),
address_type='static',
default_route=default_route,
id=len(ipv4_interfaces))
ipv4_interfaces.append(ipv4_interface)
return ipv4_interfaces
def stopip_cmd(self):
intf = self.get_docker_interface()
if intf is None:
raise ex.ContinueAction(
"can't find on which interface %s is plumbed in container %s" %
(self.addr, self.container_id()))
if self.netmask is None:
raise ex.ContinueAction("netmask is not set")
cmd = [
Env.syspaths.nsenter, "--net=" + self.netns, "ip", "addr", "del",
self.addr + "/" + to_cidr(self.netmask), "dev", intf
]
ret, out, err = self.vcall(cmd)
cmd = [
Env.syspaths.nsenter, "--net=" + self.netns, "ip", "link", "del",
"dev", intf
]
ret, out, err = self.vcall(cmd)
if self.mode == "ovs":
self.log.info("ovs mode")
ret, out, err = self.stopip_cmd_shared_ovs()
self.unset_lazy("netns")
return ret, out, err
def startip_cmd_shared_bridge(self):
nspid = self.get_nspid()
tmp_guest_dev = "v%spg%s" % (self.guest_dev, nspid)
tmp_local_dev = "v%spl%s" % (self.guest_dev, nspid)
mtu = self.ip_get_mtu()
# create peer devs
cmd = [
Env.syspaths.ip, "link", "add", "name", tmp_local_dev, "mtu", mtu,
"type", "veth", "peer", "name", tmp_guest_dev, "mtu", mtu
]
ret, out, err = self.vcall(cmd)
if ret != 0:
return ret, out, err
# activate the parent dev
cmd = [
Env.syspaths.ip, "link", "set", tmp_local_dev, "master", self.ipdev
]
ret, out, err = self.vcall(cmd)
if ret != 0:
return ret, out, err
cmd = [Env.syspaths.ip, "link", "set", tmp_local_dev, "up"]
ret, out, err = self.vcall(cmd)
if ret != 0:
return ret, out, err
# assign the macvlan interface to the container namespace
cmd = [Env.syspaths.ip, "link", "set", tmp_guest_dev, "netns", nspid]
ret, out, err = self.vcall(cmd)
if ret != 0:
return ret, out, err
# rename the tmp guest dev
cmd = [
Env.syspaths.nsenter, "--net=" + self.netns, "ip", "link", "set",
tmp_guest_dev, "name", self.final_guest_dev
]
ret, out, err = self.vcall(cmd)
if ret != 0:
return ret, out, err
# set the mac addr
self.set_macaddr()
# plumb ip
cmd = [
Env.syspaths.nsenter, "--net=" + self.netns, "ip", "addr", "add",
self.addr + "/" + to_cidr(self.netmask), "dev",
self.final_guest_dev
]
ret, out, err = self.vcall(cmd)
if ret != 0:
return ret, out, err
# setup default route
self.ip_setup_route()
return 0, "", ""
def startip_cmd(self):
if ':' in self.addr:
cmd = ['ifconfig', self.ipdev, 'inet6', 'up']
(ret, out, err) = self.vcall(cmd)
if ret != 0:
raise ex.Error
cmd = ['ifconfig', self.stacked_dev, 'inet6', self.addr+'/'+to_cidr(self.netmask), 'up']
else:
cmd = ['ifconfig', self.stacked_dev, self.addr, 'netmask', to_dotted(self.netmask), 'up']
return self.vcall(cmd)
def set_label(self):
"""
Set the resource label property.
"""
try:
self.get_mask()
except ex.Error:
pass
self.label = "netns %s %s/%s %s@%s" % (self.mode, self.ipname,
to_cidr(self.netmask),
self.ipdev, self.container_rid)
def startip_cmd_shared_macvlan(self):
nspid = self.get_nspid()
tmp_guest_dev = "ph%s%s" % (nspid, self.guest_dev)
mtu = self.ip_get_mtu()
# create a macvlan interface
cmd = [
Env.syspaths.ip, "link", "add", "link", self.ipdev, "dev",
tmp_guest_dev, "mtu", mtu, "type", "macvlan", "mode", "bridge"
]
ret, out, err = self.vcall(cmd)
if ret != 0:
return ret, out, err
# activate the parent dev
cmd = [Env.syspaths.ip, "link", "set", self.ipdev, "up"]
ret, out, err = self.vcall(cmd)
if ret != 0:
return ret, out, err
# assign the macvlan interface to the container namespace
cmd = [Env.syspaths.ip, "link", "set", tmp_guest_dev, "netns", nspid]
ret, out, err = self.vcall(cmd)
if ret != 0:
return ret, out, err
# rename the tmp guest dev
cmd = [
Env.syspaths.nsenter, "--net=" + self.netns, "ip", "link", "set",
tmp_guest_dev, "name", self.final_guest_dev
]
ret, out, err = self.vcall(cmd)
if ret != 0:
return ret, out, err
# set the mac addr
self.set_macaddr()
# plumb the ip
cmd = [
Env.syspaths.nsenter, "--net=" + self.netns, "ip", "addr", "add",
"%s/%s" % (self.addr, to_cidr(self.netmask)), "dev",
self.final_guest_dev
]
ret, out, err = self.vcall(cmd)
if ret != 0:
return ret, out, err
# setup default route
self.ip_setup_route()
return 0, "", ""
def ip_setup_route(self):
cmd = [
Env.syspaths.nsenter, "--net=" + self.netns, "ip", "link", "set",
self.final_guest_dev, "up"
]
ret, out, err = self.vcall(cmd)
if ret != 0:
return ret, out, err
cmd = [
Env.syspaths.nsenter, "--net=" + self.netns, "ip", "route", "list",
"default"
]
ret, out, err = self.call(cmd, errlog=False)
if out.startswith("default via"):
pass
elif out.startswith("default dev") and not self.gateway:
pass
elif self.gateway:
cmd = [
Env.syspaths.nsenter, "--net=" + self.netns, "ip", "route",
"replace", "default", "via", self.gateway
]
ret, out, err = self.vcall(cmd)
if ret != 0:
return ret, out, err
else:
cmd = [
Env.syspaths.nsenter, "--net=" + self.netns, "ip", "route",
"replace", "default", "dev", self.final_guest_dev
]
ret, out, err = self.vcall(cmd)
if ret != 0:
return ret, out, err
if self.del_net_route and self.network:
cmd = [
Env.syspaths.nsenter, "--net=" + self.netns, "ip", "route",
"del", self.network + "/" + to_cidr(self.netmask), "dev",
self.final_guest_dev
]
ret, out, err = self.vcall(cmd)
if ret != 0:
return ret, out, err
# announce
cmd = [Env.syspaths.nsenter, "--net=" + self.netns
] + Env.python_cmd + [
os.path.join(Env.paths.pathlib, "utilities", "arp.py"),
self.final_guest_dev, self.addr
]
self.log.info(" ".join(cmd))
out, err, ret = justcall(cmd)
def startip_cmd(self):
if ':' in self.addr:
cmd = [
'ifconfig', self.ipdev, 'inet6',
'/'.join([self.addr, to_cidr(self.netmask)]), 'add'
]
else:
cmd = [
'ifconfig', self.ipdev, 'inet', self.addr, 'netmask',
'0xffffffff', 'add'
]
return self.vcall(cmd)
def startip_cmd_dedicated(self):
# assign interface to the nspid
nspid = self.get_nspid()
if nspid is None:
raise ex.Error("could not determine nspid")
cmd = [
Env.syspaths.ip, "link", "set", self.ipdev, "netns", nspid, "name",
self.final_guest_dev
]
ret, out, err = self.vcall(cmd)
if ret != 0:
return ret, out, err
# plumb the ip
cmd = [
Env.syspaths.nsenter, "--net=" + self.netns, "ip", "addr", "add",
"%s/%s" % (self.addr, to_cidr(self.netmask)), "dev",
self.final_guest_dev
]
ret, out, err = self.vcall(cmd)
if ret != 0:
return ret, out, err
# activate
cmd = [
Env.syspaths.nsenter, "--net=" + self.netns, "ip", "link", "set",
self.final_guest_dev, "up"
]
ret, out, err = self.vcall(cmd)
if ret != 0:
return ret, out, err
# add default route
if self.gateway:
cmd = [
Env.syspaths.nsenter, "--net=" + self.netns, "ip", "route",
"add", "default", "via", self.gateway, "dev",
self.final_guest_dev
]
ret, out, err = self.vcall(cmd)
if ret != 0:
return ret, out, err
# announce
cmd = [Env.syspaths.nsenter, "--net=" + self.netns
] + Env.python_cmd + [
os.path.join(Env.paths.pathlib, "utilities", "arp.py"),
self.final_guest_dev, self.addr
]
self.log.info(" ".join(cmd))
out, err, ret = justcall(cmd)
return 0, "", ""
def startip_cmd(self):
if ':' in self.addr:
cmd = [
'ifconfig', self.ipdev, 'inet6', 'alias',
'/'.join([self.addr, to_cidr(self.netmask)])
]
else:
cmd = [
'ifconfig', self.ipdev, self.addr, 'netmask',
to_dotted(self.netmask), 'alias'
]
return self.vcall(cmd)
def label(self): # pylint: disable=method-hidden
intf = self.get_ipdev()
label = "cni "
label += self.network if self.network else ""
if intf and len(intf.ipaddr) > 0:
label += " %s/%s" % (intf.ipaddr[0], to_cidr(intf.mask[0]))
elif intf and len(intf.ip6addr) > 0:
label += " %s/%s" % (intf.ip6addr[0], intf.ip6mask[0])
if self.ipdev:
label += " %s" % self.ipdev
if self.expose:
label += " %s" % " ".join(self.expose)
return label
def startip_cmd(self):
cmd = [
"/usr/sbin/ifconfig",
self.stacked_dev,
"plumb",
self.addr,
"netmask",
cidr_to_dotted(to_cidr(self.netmask)),
"broadcast",
"+",
"up",
]
return self.vcall(cmd)
def stopip_cmd(self):
if which("ifconfig") and self.alias:
if ':' in self.addr:
cmd = [
'ifconfig', self.ipdev, 'inet6', 'del',
'/'.join([self.addr, to_cidr(self.netmask)])
]
else:
if self.stacked_dev is None:
return 1, "", "no stacked dev found"
if ":" in self.stacked_dev:
cmd = ['ifconfig', self.stacked_dev, 'down']
else:
cmd = [
Env.syspaths.ip, "addr", "del",
'/'.join([self.addr,
to_cidr(self.netmask)]), "dev", self.ipdev
]
else:
cmd = [
Env.syspaths.ip, "addr", "del",
'/'.join([self.addr, to_cidr(self.netmask)]), "dev", self.ipdev
]
return self.vcall(cmd)
def set_label(self):
"""
Set the resource label property.
"""
try:
self.get_mask()
except ex.Error:
pass
try:
self.getaddr()
addr = self.addr
except ex.Error:
addr = self.ipname
self.label = "%s/%s %s/%s" % (addr, to_cidr(
self.netmask), self.ipdev, self.ipdevext)
if self.ipname != addr:
self.label += " " + self.ipname
def _info(self):
"""
Contribute resource key/val pairs to the service's resinfo.
"""
if self.ipname is None:
return []
try:
self.getaddr()
except ex.Error:
pass
data = [
["ipaddr", self.addr],
["ipname", self.ipname],
["ipdev", self.ipdev],
["gateway", str(self.gateway)],
]
if self.netmask is not None:
data.append(["netmask", str(to_cidr(self.netmask))])
return data
def startip_cmd(self):
if not which(Env.syspaths.ipadm):
raise ex.Error("crossbow ips are not supported on this system")
if self.netmask is None:
raise ex.Error("netmask not specified nor guessable")
self.wait_net_smf()
ret, out, err = (0, '', '')
cmd = [
Env.syspaths.ipadm, 'show-if', '-p', '-o', 'state',
self.stacked_dev
]
_out, err, ret = justcall(cmd)
_out = _out.strip().split("\n")
if len(_out) == 0:
cmd = [Env.syspaths.ipadm, 'create-ip', '-t', self.stacked_dev]
r, o, e = self.vcall(cmd)
cmd = [
Env.syspaths.ipadm, 'create-addr', '-t', '-T', 'static', '-a',
self.addr + "/" + to_cidr(self.netmask),
self.stacked_dev + '/' + self.ipdevext
]
r, o, e = self.vcall(cmd)
if r != 0:
cmd = [Env.syspaths.ipadm, 'show-if']
self.vcall(cmd)
raise ex.Error(
"Interface %s is not up. ipadm cannot create-addr over it. Retrying..."
% self.stacked_dev)
ret += r
out += o
err += e
if self.gateway is not None:
cmd = ['route', '-q', 'add', 'default', self.gateway]
r, o, e = self.call(cmd, info=True, outlog=False, errlog=False)
ret += r
return ret, out, err
def _status_info(self):
"""
Contribute resource key/val pairs to the resource info.
"""
data = {}
try:
self.getaddr()
except ex.Error:
pass
try:
data["ipaddr"] = self.addr
except:
pass
if self.ipdev:
data["ipdev"] = self.ipdev
if self.gateway:
data["gateway"] = self.gateway
if self.netmask is not None:
data["netmask"] = to_cidr(self.netmask)
if self.expose:
data["expose"] = self.expose
return data
def startip_cmd_shared_ovs(self):
nspid = self.get_nspid()
tmp_guest_dev = "v%spg%s" % (self.guest_dev, nspid)
tmp_local_dev = "v%spl%s" % (self.guest_dev, nspid)
mtu = self.ip_get_mtu()
if not which("ovs-vsctl"):
raise Exception("ovs-vsctl must be installed")
# create peer devs
cmd = [
Env.syspaths.ip, "link", "add", "name", tmp_local_dev, "mtu", mtu,
"type", "veth", "peer", "name", tmp_guest_dev, "mtu", mtu
]
ret, out, err = self.vcall(cmd)
if ret != 0:
return ret, out, err
cmd = [
"ovs-vsctl", "--may-exist", "add-port", self.ipdev, tmp_local_dev,
"vlan_mode=%s" % self.vlan_mode
]
if self.vlan_tag is not None:
cmd += ["tag=%s" % self.vlan_tag]
ret, out, err = self.vcall(cmd)
if ret != 0:
return ret, out, err
cmd = [Env.syspaths.ip, "link", "set", tmp_local_dev, "up"]
ret, out, err = self.vcall(cmd)
if ret != 0:
return ret, out, err
# assign the interface to the container namespace
cmd = [Env.syspaths.ip, "link", "set", tmp_guest_dev, "netns", nspid]
ret, out, err = self.vcall(cmd)
if ret != 0:
return ret, out, err
# rename the tmp guest dev
cmd = [
Env.syspaths.nsenter, "--net=" + self.netns, "ip", "link", "set",
tmp_guest_dev, "name", self.final_guest_dev
]
ret, out, err = self.vcall(cmd)
if ret != 0:
return ret, out, err
# plumb ip
cmd = [
Env.syspaths.nsenter, "--net=" + self.netns, "ip", "addr", "add",
self.addr + "/" + to_cidr(self.netmask), "dev",
self.final_guest_dev
]
ret, out, err = self.vcall(cmd)
if ret != 0:
return ret, out, err
# setup default route
self.ip_setup_route()
return 0, "", ""
