def __pre_check(self):
# Check if the name of the new network is given
if not self.network_id:
emsg = "Missing name of the virtual network that should be configured with a route."
self.logger.error("[localhost] WeaveNetworkGateway: %s" % (emsg))
self.exit()
# Check if the name of new network is not a duplicate (that it does not already exists).
if not self._networkExists():
emsg = "virtual network %s does not exist." % (self.network_id)
self.logger.error("[%s] WeaveNetworkGateway: %s" %
(self.network_id, emsg))
self.exit()
if not self.delete:
self.add = True
self.fabric_id = self.getFabricId()
if not self.fabric_id:
emsg = "weave fabric id is unknown."
self.logger.error("[%s] WeaveNetworkGateway: %s" %
(self.network_id, emsg))
self.exit()
self.global_prefix = self.getWeaveGlobalPrefix(self.fabric_id)
if not self.global_prefix:
emsg = "weave fabric prefix is unknown."
self.logger.error("[%s] WeaveNetworkGateway: %s" %
(self.network_id, emsg))
self.exit()
# Check if 'gateway' is given
if not self.gateway:
emsg = "Missing gateway address for weave fabric."
self.logger.error("[%s] WeaveNetworkGateway: %s" %
(self.network_id, emsg))
self.exit()
if not self._nodeExists(self.gateway):
emsg = "Proposed gateway node %s does not exist." % (self.gateway)
self.logger.error("[%s] WeaveNetworkGateway: %s" %
(self.network_id, emsg))
self.exit()
if IP.isIpAddress(self.gateway):
self.gateway = IP.paddingZeros(self.gateway)
self.to = IP.paddingZeros(self.global_prefix)
def __nodeRouteExistsViaDevice(self, to, dev):
if to != 'default':
to = IP.paddingZeros(to)
# IPv4
cmd = "ip route"
cmd = self.runAsRoot(cmd)
out, err = self.CallAtNodeForOutput(self.node_id, cmd)
if out is not None:
for line in out.split("\n"):
l = line.split()
if len(l) < 3:
continue
if to == 'default':
if l[0] == to and l[1] == "dev" and l[2] == dev:
if self.route_table is not None:
if self.nodeIpv4TableExist(self.node_id) is True:
return True
return True
else:
if IP.paddingZeros(
l[0]) == to and l[1] == "dev" and l[2] == dev:
if self.route_table is not None:
if self.nodeIpv4TableExist(self.node_id) is True:
return True
return True
# IPv6
cmd = "ip -6 route"
cmd = self.runAsRoot(cmd)
out, err = self.CallAtNodeForOutput(self.node_id, cmd)
if out is not None:
for line in out.split("\n"):
l = line.split()
if len(l) < 3:
continue
if IP.paddingZeros(
l[0]) == to and l[1] == "dev" and l[2] == dev:
return True
return False
def __pre_check(self):
# Check if the name of the new node is given
if not self.node_id:
emsg = "Missing name of the new virtual node that IP address should be managed."
self.logger.error("[localhost] HappyNodeAddress: %s" % (emsg))
self.exit()
# Check if the name of new node is not a duplicate (that it does not already exists).
if not self._nodeExists():
emsg = "virtual node %s does not exist." % (self.node_id)
self.logger.warning("[%s] HappyNodeAddress: %s" %
(self.node_id, emsg))
# Check if the name of the interface is given
if not self.interface:
emsg = "Missing name of the network interface in virtual node."
self.logger.error("[%s] HappyNodeAddress: %s" %
(self.node_id, emsg))
self.exit()
# Check if node has a given interface
if not self._nodeInterfaceExists(self.interface, self.node_id):
emsg = "virtual node %s does not have interface %s." % (
self.node_id, self.interface)
self.logger.warning("[%s] HappyNodeAddress: %s" %
(self.node_id, emsg))
self.exit()
# Check if address is given
if not self.address:
emsg = "Missing IP address for virtual node."
self.logger.error("[%s] HappyNodeAddress: %s" %
(self.node_id, emsg))
self.exit()
self.ip_address, self.ip_mask = IP.splitAddressMask(self.address)
self.ip_address = IP.paddingZeros(self.ip_address)
if not self.delete:
self.add = True
# Check if node has given prefix
addr_prefix = IP.getPrefix(self.ip_address, self.ip_mask)
if self.delete and addr_prefix not in self.getNodeInterfacePrefixes(
self.interface):
emsg = "virtual node %s may not have any addresses on prefix %s." % (
self.node_id, addr_prefix)
self.logger.warning("[%s] HappyNodeAddress: %s" %
(self.node_id, emsg))
# Check if node has this address already
if self.add and self.address in self.getNodeInterfaceAddresses(
self.interface):
emsg = "virtual node %s already has addresses %s." % (self.node_id,
self.address)
self.logger.error("[%s] HappyNodeAddress: %s" %
(self.node_id, emsg))
self.done = True
def __getNodeIPv6AddressOnPrefix(self, prefix, id):
prefix_addr, prefix_mask = IP.splitAddressMask(prefix)
addr = prefix_addr + "::" + id
if addr.count(":") == 8:
addr = addr.replace("::", ":")
addr = IP.paddingZeros(addr)
return addr
def getIpAddressStatus(self, address, interface_id=None, node_id=None):
out = self.getIpAddressesRecords(interface_id, node_id)
for line in out.split("\n"):
l = line.split()
if l[0][:4] == "inet":
addr = l[1]
addr, mask = addr.split("/")
addr = IP.paddingZeros(addr)
if addr != address:
continue
return line
return None
def getIpAddresses(self, interface_id=None, node_id=None):
out = self.getIpAddressesRecords(interface_id, node_id)
ipaddrs = []
for line in out.split("\n"):
l = line.split()
if len(l) < 4:
continue
if l[0][:4] == "inet":
addr = l[1]
addr, mask = addr.split("/")
addr = IP.paddingZeros(addr)
ipaddrs.append(addr)
return ipaddrs
def __pre_check(self):
# Check if the name of the new node is given
if not self.node_id:
emsg = "Missing name of the new virtual node that IP routes should be managed."
self.logger.error("[localhost] HappyNodeRoute: %s" % (emsg))
self.exit()
# Check if the name of new node is not a duplicate (that it does not already exists).
if not self._nodeExists():
emsg = "virtual node %s does not exist." % (self.node_id)
self.logger.warning("[%s] HappyNodeRoute: %s" % (self.node_id, emsg))
if not self.delete:
self.add = True
# Check if address is given
if not self.to:
emsg = "Missing address for virtual node destination (to)."
self.logger.error("[%s] HappyNodeRoute: %s" % (self.node_id, emsg))
self.exit()
# Check if address is given
if not self.via:
emsg = "Missing address for virtual gateway (via)."
self.logger.error("[%s] HappyNodeRoute: %s" % (self.node_id, emsg))
self.exit()
# Check for mix IP addresses
if IP.isIpAddress(self.to) and IP.isIpAddress(self.via) and IP.isIpv6(self.to) != IP.isIpv6(self.via):
emsg = "Mixing addresses %s and %s." % (self.to, self.via)
self.logger.error("[%s] HappyNodeRoute: %s" % (self.node_id, emsg))
self.exit()
# Check if destination is a node
if self.to != "default" and not IP.isIpAddress(self.to):
if not self._nodeExists(self.to):
emsg = "Don't know what %s to-address is. If it is a node, it can't be found." % (self.to)
self.logger.error("[localhost] HappyNodeRoute: %s" % (emsg))
self.exit()
else:
# 'to' is a node
emsg = "Destination address must be 'default' or a IP address."
self.logger.error("[localhost] HappyNodeRoute: %s" % (emsg))
self.exit()
if IP.isIpAddress(self.to):
self.to = IP.paddingZeros(self.to)
# Check if gateway is a node
if IP.isIpAddress(self.via):
self.via_address = self.via
self.via_address = IP.paddingZeros(self.via_address)
return
if self._nodeInterfaceExists(self.via):
self.via_device = self.via
return
if not self._nodeExists(self.via):
emsg = "Don't know what %s via-address is. If it is a node, it can't be found." % (self.to)
self.logger.error("[localhost] HappyNodeRoute: %s" % (emsg))
self.exit()
this_node_networks = self.getNodeNetworkIds(self.node_id)
gateway_networks = self.getNodeNetworkIds(self.via)
common_networks = list(set(this_node_networks).intersection(gateway_networks))
if len(common_networks) == 0:
emsg = "Node %s and gateway node %s are not on the same network." % \
(self.node_id, self.via)
self.logger.error("[localhost] HappyNodeRoute: %s" % (emsg))
self.exit()
if len(common_networks) > 1 and not self.prefix:
emsg = "Node %s and gateway %s share more than one network. Need gateway prefix to disambiguate." % \
(self.node_id, self.via)
self.logger.error("[localhost] HappyNodeRoute: %s" % (emsg))
self.exit()
if not self.prefix:
gateway_addresses = self.getNodeAddressesOnNetwork(common_networks[0], self.via)
if len(gateway_addresses) == 0:
emsg = "Gateway node (via) %s does not have any IP addresses." % \
(self.via)
self.logger.error("[localhost] HappyNodeRoute: %s" % (emsg))
self.exit()
if len(gateway_addresses) > 1 and self.prefix is None:
emsg = "Node %s has more than one IP address. Need gateway prefix to disambiguate." % \
(self.via)
self.logger.error("[localhost] HappyNodeRoute: %s" % (emsg))
self.exit()
# We find gateway address without using prefix.
self.via_address = gateway_addresses[0]
return
else:
if not IP.isIpAddress(self.prefix):
emsg = "Prefix %s is not a valid IP address."
self.logger.error("[localhost] HappyNodeRoute: %s" % (emsg))
self.exit()
self.ip_prefix, self.ip_mask = IP.splitAddressMask(self.prefix)
self.prefix = IP.getPrefix(self.ip_prefix, self.ip_mask)
gateway_addresses = self.getNodeAddressesOnNetworkOnPrefix(common_networks[0], self.prefix, self.via)
if len(gateway_addresses) == 0:
emsg = "Cannot find any IP address on %s with prefix %s." % (self.via, self.prefix)
self.logger.error("[localhost] HappyNodeRoute: %s" % (emsg))
self.exit()
if len(gateway_addresses) > 1:
emsg = "Found more than one IP address on %s with prefix %s. (%s)" % \
(self.via, self.prefix, ",".join(gateway_addresses))
self.logger.error("[localhost] HappyNodeRoute: %s" % (emsg))
self.exit()
self.via_address = gateway_addresses[0]
def __pre_check(self):
# Check if the name of the new network is given
if not self.network_id:
emsg = "Missing name of the virtual network that should be configured with a route."
self.logger.error("[localhost] HappyNetworkRoute: %s" % (emsg))
self.exit()
# Check if the name of new network is not a duplicate (that it does not already exists).
if not self._networkExists():
emsg = "virtual network %s does not exist." % (self.network_id)
self.logger.error("[%s] HappyNetworkRoute: %s" % (self.network_id, emsg))
self.exit()
if not self.delete:
self.add = True
# Check if 'to' is given
if not self.to:
emsg = "Missing destination address for virtual network (to)."
self.logger.error("[%s] HappyNetworkRoute: %s" % (self.node_id, emsg))
self.exit()
# Check if 'via' is given
if not self.via:
emsg = "Missing gateway address for virtual network (via)."
self.logger.error("[%s] HappyNetworkRoute: %s" % (self.node_id, emsg))
self.exit()
# Check for mix IP addresses
if IP.isIpAddress(self.to) and IP.isIpAddress(self.via) and IP.isIpv6(self.to) != IP.isIpv6(self.via):
emsg = "Mixing addresses %s and %s." % (self.to, self.via)
self.logger.error("[%s] HappyNetworkRoute: %s" % (self.node_id, emsg))
self.exit()
# Check if destination is a node
if self.to != "default" and not IP.isIpAddress(self.to):
if not self._nodeExists(self.to):
emsg = "Don't know what %s to-address is. If it is a node, it can't be found." % (self.to)
self.logger.error("[localhost] HappyNetworkRoute: %s" % (emsg))
self.exit()
else:
# 'to' is a node
emsg = "Destination address must be 'default' or a IP address."
self.logger.error("[localhost] HappyNetworkRoute: %s" % (emsg))
self.exit()
if IP.isIpAddress(self.to):
self.to = IP.paddingZeros(self.to)
# Check if gateway is an address or a node
if IP.isIpAddress(self.via):
self.via = IP.paddingZeros(self.via)
self.via_node = self.getNodeIdFromAddress(self.via)
if self.via_node is None or not self._nodeExists(self.via_node):
emsg = "Cannot find a node that would match %s." % (self.via)
self.logger.error("[localhost] HappyNetworkRoute: %s" % (emsg))
self.exit()
return
if self._nodeExists(self.via):
self.via_node = self.via
