def __pre_check(self):
# Check if the name of the new node is given
if not self.source:
emsg = "Missing name of the virtual source node."
self.logger.error("[localhost] Ping: %s" % (emsg))
self.exit()
# Check if the source node exists.
if not self._nodeExists(self.source):
emsg = "virtual source node %s does not exist." % (self.source)
self.logger.error("[%s] Ping: %s" % (self.source, emsg))
self.exit()
# Check if the ping destination is given.
if not self.destination:
emsg = "Missing destination for ping."
self.logger.error("[localhost] Ping: %s" % (emsg))
self.exit()
# Check if the destination node exists.
if not IP.isIpAddress(self.destination) and not self._nodeExists(
self.destination):
emsg = "virtual destination node %s does not exist." % (
self.destination)
self.logger.error("[%s] Ping: %s" % (self.source, emsg))
self.exit()
if self.count is not None and self.count.isdigit():
self.count = int(float(self.count))
else:
self.count = 1
def __pre_check(self):
# Check if the name of the new node is given
if not self.source:
emsg = "Missing name of the virtual source node."
self.logger.error("[localhost] Traceroute: %s" % (emsg))
self.exit()
# Check if the source node exists.
if not self._nodeExists(self.source):
emsg = "virtual source node %s does not exist." % (self.source)
self.logger.error("[%s] Traceroute: %s" % (self.source, emsg))
self.exit()
# Check if the traceroute destination is given.
if not self.destination:
emsg = "Missing destination for traceroute."
self.logger.error("[localhost] Traceroute: %s" % (emsg))
self.exit()
# Check if the destination node exists.
if not IP.isIpAddress(self.destination) and not self._nodeExists(
self.destination):
emsg = "virtual destination node %s does not exist." % (
self.destination)
self.logger.error("[%s] Traceroute: %s" % (self.source, emsg))
self.exit()
def run(self):
self.__pre_check()
self.__get_addresses()
if self.addresses == {}:
emsg = "No address to ping at " + str(self.destination) + "."
self.logger.warning("[%s] Ping: %s" % (self.source, emsg))
print hyellow(emsg)
return ReturnMsg(100, self.addresses)
for addr in self.addresses.keys():
out, err = self.__ping_on_address(addr)
self.__parse_output(addr, out, err)
self.__post_check()
for addr in self.addresses.keys():
if IP.isIpAddress(self.destination):
self.logger.info("ping from " + self.source + " to address " +
addr + " -> " + str(self.addresses[addr]) +
"% packet loss")
else:
self.logger.info("ping from " + self.source + " to " +
self.destination + " on address " + addr +
" -> " + str(self.addresses[addr]) +
"% packet loss")
return ReturnMsg(self.ret, self.addresses)
def __get_addresses(self):
self.addresses = {}
if IP.isIpAddress(self.destination):
self.addresses[self.destination] = None
return
if self._nodeExists(self.destination):
node_addresses = self.getNodeAddresses(self.destination)
for addr in node_addresses:
self.addresses[addr] = {}
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 __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):
# clear network info
self.clients_info = []
# Make sure that fabric was created
if self.getFabricId() == None:
emsg = "Weave Fabric has not been created yet."
self.logger.error("[localhost] WeaveBle: %s" % (emsg))
sys.exit(1)
for client in self.clients:
client_node_id = None
# Check if Weave Ble client node is given.
if client == None:
emsg = "Missing name or address of the Weave Ble client node."
self.logger.error("[localhost] WeaveBle: %s" % (emsg))
sys.exit(1)
# Check if Weave Ble client node exists.
if self._nodeExists(client):
client_node_id = client
# Check if client is provided in a form of IP address
if IP.isIpAddress(client):
client_node_id = self.getNodeIdFromAddress(client)
if client_node_id == None:
emsg = "Unknown identity of the client node."
self.logger.error("[localhost] WeaveBle: %s" % (emsg))
sys.exit(1)
if self.getNodeType(client_node_id) == "service":
client_ip = self.getServiceWeaveIPAddress(
self.endpoint, client_node_id)
client_weave_id = self.getServiceWeaveID(
self.endpoint, client_node_id)
else:
client_ip = self.getNodeWeaveIPAddress(client_node_id)
client_weave_id = self.getWeaveNodeID(client_node_id)
if client_ip == None:
emsg = "Could not find IP address of the client node."
self.logger.error("[localhost] WeaveBle: %s" % (emsg))
sys.exit(1)
if client_weave_id == None:
emsg = "Could not find Weave node ID of the client node."
self.logger.error("[localhost] WeaveBle: %s" % (emsg))
sys.exit(1)
self.clients_info.append({
'client':
client,
'client_node_id':
client_node_id,
'client_ip':
client_ip,
'client_weave_id':
client_weave_id,
'client_process_tag':
client + "_" + self.client_process_tag + client
})
# Check if Weave Ble server node is given.
if self.server == None:
emsg = "Missing name or address of the Weave Ble server node."
self.logger.error("[localhost] WeaveBle: %s" % (emsg))
sys.exit(1)
# Check if Weave Ble server node exists.
if self._nodeExists(self.server):
self.server_node_id = self.server
# Check if server is provided in a form of IP address
if IP.isIpAddress(self.server):
self.no_service = True
self.server_ip = self.server
self.server_weave_id = self.IPv6toWeaveId(self.server)
elif IP.isDomainName(self.server) or self.server == "service":
self.no_service = True
self.server_ip = self.getServiceWeaveIPAddress(self.endpoint)
self.server_weave_id = self.IPv6toWeaveId(self.server_ip)
else:
# Check if server is a true clound service instance
if self.getNodeType(self.server) == self.node_type_service:
self.no_service = True
if not self.no_service and self.server_node_id == None:
emsg = "Unknown identity of the server node."
self.logger.error("[localhost] WeaveBle: %s" % (emsg))
sys.exit(1)
if self.getNodeType(self.server_node_id) == "service":
self.server_ip = self.getServiceWeaveIPAddress(
self.endpoint, self.server_node_id)
self.server_weave_id = self.getServiceWeaveID(
self.endpoint, self.server_node_id)
else:
if not self.no_service:
self.server_ip = self.getNodeWeaveIPAddress(
self.server_node_id)
self.server_weave_id = self.getWeaveNodeID(self.server_node_id)
# Check if all unknowns were found
if self.server_ip == None:
emsg = "Could not find IP address of the server node."
self.logger.error("[localhost] WeaveBle: %s" % (emsg))
sys.exit(1)
if not self.no_service and self.server_weave_id == None:
emsg = "Could not find Weave node ID of the server node."
self.logger.error("[localhost] WeaveBle: %s" % (emsg))
sys.exit(1)
def __pre_check(self):
# Check if Weave Ping client node is given.
if self.client == None:
emsg = "Missing name or address of the Weave Ping client node."
self.logger.error("[localhost] WeaveSecurityPing: %s" % (emsg))
sys.exit(1)
# Check if Weave Ping server node is given.
if self.server == None:
emsg = "Missing name or address of the Weave Ping server node."
self.logger.error("[localhost] WeaveSecurityPing: %s" % (emsg))
sys.exit(1)
# Make sure that fabric was created
if self.getFabricId() == None:
emsg = "Weave Fabric has not been created yet."
self.logger.error("[localhost] WeaveSecurityPing: %s" % (emsg))
sys.exit(1)
if self.count != None and self.count.isdigit():
self.count = int(float(self.count))
else:
self.count = 1
# Check if Weave Ping client node exists.
if self._nodeExists(self.client):
self.client_node_id = self.client
# Check if Weave Ping server node exists.
if self._nodeExists(self.server):
self.server_node_id = self.server
# Check if client is provided in a form of IP address
if IP.isIpAddress(self.client):
self.client_node_id = self.getNodeIdFromAddress(self.client)
# Check if server is provided in a form of IP address
if IP.isIpAddress(self.server):
self.no_service = True
self.server_ip = self.server
self.server_weave_id = self.IPv6toWeaveId(self.server)
else:
# Check if server is a true clound service instance
if self.getNodeType(self.server) == self.node_type_service:
self.no_service = True
if self.client_node_id == None:
emsg = "Unknown identity of the client node."
self.logger.error("[localhost] WeaveSecurityPing: %s" % (emsg))
sys.exit(1)
if not self.no_service and self.server_node_id == None:
emsg = "Unknown identity of the server node."
self.logger.error("[localhost] WeaveSecurityPing: %s" % (emsg))
sys.exit(1)
if self.getNodeType(self.client_node_id) == "service":
self.client_ip = self.getServiceWeaveIPAddress(
"Echo", self.client_node_id)
self.client_weave_id = self.getServiceWeaveID(
"Echo", self.client_node_id)
else:
self.client_ip = self.getNodeWeaveIPAddress(self.client_node_id)
self.client_weave_id = self.getWeaveNodeID(self.client_node_id)
if self.getNodeType(self.server_node_id) == "service":
self.server_ip = self.getServiceWeaveIPAddress(
"Echo", self.server_node_id)
self.server_weave_id = self.getServiceWeaveID(
"Echo", self.server_node_id)
else:
if not self.no_service:
self.server_ip = self.getNodeWeaveIPAddress(
self.server_node_id)
self.server_weave_id = self.getWeaveNodeID(self.server_node_id)
# Check if all unknowns were found
if self.client_ip == None:
emsg = "Could not find IP address of the client node."
self.logger.error("[localhost] WeaveSecurityPing: %s" % (emsg))
sys.exit(1)
if self.server_ip == None:
emsg = "Could not find IP address of the server node."
self.logger.error("[localhost] WeaveSecurityPing: %s" % (emsg))
sys.exit(1)
if self.client_weave_id == None:
emsg = "Could not find Weave node ID of the client node."
self.logger.error("[localhost] WeaveSecurityPing: %s" % (emsg))
sys.exit(1)
if not self.no_service and self.server_weave_id == None:
emsg = "Could not find Weave node ID of the server node."
self.logger.error("[localhost] WeaveSecurityPing: %s" % (emsg))
sys.exit(1)
num_security_modes = 0
if self.case == True:
num_security_modes += 1
if self.pase == True:
num_security_modes += 1
if self.group_key == True:
num_security_modes += 1
if num_security_modes > 1:
emsg = "Only one security mode can be enabled."
self.logger.error("[localhost] WeaveSecurityPing: %s" % (emsg))
sys.exit(1)
def __pre_check(self):
# Check if Weave BDX client node is given.
if self.client == None:
emsg = "Missing name or address of the Weave BDX client node."
self.logger.error("[localhost] WeaveBDX: %s" % (emsg))
sys.exit(1)
# Check if Weave BDX server node is given.
if self.server == None:
emsg = "Missing name or address of the Weave BDX server node."
self.logger.error("[localhost] WeaveBDX: %s" % (emsg))
sys.exit(1)
# Check if Weave BDX server version is correct.
if self.server_version != 0 and self.server_version != 1:
emsg = "BDX server version is not correct."
self.logger.error("[localhost] WeaveBDX: %s" % (emsg))
sys.exit(1)
# Check if Weave BDX client version is correct.
if self.client_version != 0 and self.client_version != 1:
emsg = "BDX client version is not correct."
self.logger.error("[localhost] WeaveBDX: %s" % (emsg))
sys.exit(1)
# Make sure that fabric was created
if self.getFabricId() == None:
emsg = "Weave Fabric has not been created yet."
self.logger.error("[localhost] WeaveBDX: %s" % (emsg))
sys.exit(1)
# Check if Weave BDX client node exists.
if self._nodeExists(self.client):
self.client_node_id = self.client
# Check if Weave BDX server node exists.
if self._nodeExists(self.server):
self.server_node_id = self.server
# Check if client is provided in a form of IP address
if IP.isIpAddress(self.client):
self.client_node_id = self.getNodeIdFromAddress(self.client)
# Check if server is provided in a form of IP address
if IP.isIpAddress(self.server):
self.server_node_id = self.getNodeIdFromAddress(self.server)
elif self.server == "service":
if self.download is not None:
self.server_ip = self.getServiceWeaveIPAddress("FileDownload")
elif self.upload is not None:
self.server_ip = self.getServiceWeaveIPAddress("LogUpload")
self.server_weave_id = self.IPv6toWeaveId(self.server_ip)
self.server_node_id = "service"
if self.client_node_id == None:
emsg = "Unknown identity of the client node."
self.logger.error("[localhost] WeaveBDX: %s" % (emsg))
sys.exit(1)
if self.server_node_id == None:
emsg = "Unknown identity of the server node."
self.logger.error("[localhost] WeaveBDX: %s" % (emsg))
sys.exit(1)
self.client_ip = self.getNodeWeaveIPAddress(self.client_node_id)
self.client_weave_id = self.getWeaveNodeID(self.client_node_id)
if self.server is not "service":
self.server_ip = self.getNodeWeaveIPAddress(self.server_node_id)
self.server_weave_id = self.getWeaveNodeID(self.server_node_id)
# Check if all unknowns were found
if self.client_ip == None:
emsg = "Could not find IP address of the client node."
self.logger.error("[localhost] WeaveBDX: %s" % (emsg))
sys.exit(1)
if self.server_ip == None:
emsg = "Could not find IP address of the server node."
self.logger.error("[localhost] WeaveBDX: %s" % (emsg))
sys.exit(1)
if self.client_weave_id == None:
emsg = "Could not find Weave node ID of the client node."
self.logger.error("[localhost] WeaveBDX: %s" % (emsg))
sys.exit(1)
if self.server_weave_id == None:
emsg = "Could not find Weave node ID of the server node."
self.logger.error("[localhost] WeaveBDX: %s" % (emsg))
sys.exit(1)
# Check tmp, upload, download, receive paths
if self.server is not "service":
if self.tmp == None:
emsg = "Missing path to a temporaty directory that is used by BDX server."
self.logger.error("[localhost] WeaveBDX: %s" % (emsg))
sys.exit(1)
if not os.path.isdir(self.tmp):
emsg = "The server BDX temp %s is not a directory." % (
self.tmp)
self.logger.error("[localhost] WeaveBDX: %s" % (emsg))
sys.exit(1)
if self.receive == None:
emsg = "Missing path to receiving directory."
self.logger.error("[localhost] WeaveBDX: %s" % (emsg))
sys.exit(1)
if not os.path.isdir(self.receive):
emsg = "The receiving path %s is not a directory." % (self.receive)
self.logger.error("[localhost] WeaveBDX: %s" % (emsg))
sys.exit(1)
if (self.download == None and self.upload == None) or \
(self.download != None and self.upload != None):
emsg = "Either download or upload path must be specified."
self.logger.error("[localhost] WeaveBDX: %s" % (emsg))
sys.exit(1)
if self.offset != None:
self.offset = str(self.offset)
if not self.offset.isdigit():
emsg = "File offset must be a number, not %s." % (self.offset)
self.logger.error("[localhost] WeaveBDX: %s" % (emsg))
sys.exit(1)
if self.length != None:
self.length = str(self.length)
if not self.length.isdigit():
emsg = "File length must be a number, not %s." % (self.length)
self.logger.error("[localhost] WeaveBDX: %s" % (emsg))
sys.exit(1)
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
def __pre_check(self):
# Make sure that fabric was created
if self.getFabricId() == None:
emsg = "Weave Fabric has not been created yet."
self.logger.error("[localhost] WeaveWdmNext: %s" % (emsg))
sys.exit(1)
# Check if Weave WDM server node is given.
if self.server == None:
emsg = "Missing name or address of the WeaveWdmNext server node."
self.logger.error("[localhost] WeaveWdmNext: %s" % (emsg))
sys.exit(1)
# Check if WeaveWdmNext server node exists.
if self._nodeExists(self.server):
self.server_node_id = self.server
self.server_process_tag = self.server_node_id + "_" + self.server_process_tag
# Check if server is provided in a form of IP address
if IP.isIpAddress(self.server):
self.no_service = True
self.server_ip = self.server
self.server_weave_id = self.IPv6toWeaveId(self.server)
elif IP.isDomainName(self.server) or self.server == "service":
self.no_service = True
self.server_ip = self.getServiceWeaveIPAddress("DataManagement")
self.server_weave_id = self.IPv6toWeaveId(self.server_ip)
else:
# Check if server is a true cloud service instance
if self.getNodeType(self.server) == self.node_type_service:
self.no_service = True
if not self.no_service and self.server_node_id is None:
emsg = "Unknown identity of the server node."
self.logger.error("[localhost] WeaveWdmNext: %s" % emsg)
sys.exit(1)
if self.getNodeType(self.server_node_id) == "service":
self.server_ip = self.getServiceWeaveIPAddress(
"WeaveWdmNext", self.server_node_id)
self.server_weave_id = self.getServiceWeaveID(
"WeaveWdmNext", self.server_node_id)
else:
if not self.no_service:
self.server_ip = self.getNodeWeaveIPAddress(
self.server_node_id)
self.server_weave_id = self.getWeaveNodeID(self.server_node_id)
if self.server_ip is None:
emsg = "Could not find IP address of the server node."
self.logger.error("[localhost] WeaveWdmNext: %s" % emsg)
sys.exit(1)
if not self.no_service and self.server_weave_id is None:
emsg = "Could not find Weave node ID of the server node."
self.logger.error("[localhost] WeaveWdmNext: %s" % emsg)
sys.exit(1)
for client in self.clients:
client_node_id = None
client_ip = None
client_weave_id = None
# Check if Weave Wdm Next client node is given.
if client == None:
emsg = "Missing name or address of the WeaveWdmNext client node."
self.logger.error("[localhost] WeaveWdmNext: %s" % (emsg))
sys.exit(1)
# Check if WeaveWdmNext client node exists.
if self._nodeExists(client):
client_node_id = client
# Check if client is provided in a form of IP address
if IP.isIpAddress(client):
client_node_id = self.getNodeIdFromAddress(client)
if client_node_id is None:
emsg = "Unknown identity of the client node."
self.logger.error("[localhost] WeaveWdmNext: %s" % emsg)
sys.exit(1)
if self.getNodeType(client_node_id) == "service":
client_ip = self.getServiceWeaveIPAddress(
"WeaveWdmNext", client_node_id)
client_weave_id = self.getServiceWeaveID(
"WeaveWdmNext", client_node_id)
else:
client_ip = self.getNodeWeaveIPAddress(client_node_id)
client_weave_id = self.getWeaveNodeID(client_node_id)
if client_ip is None:
emsg = "Could not find IP address of the client node."
self.logger.error("[localhost] WeaveWdmNext: %s" % emsg)
sys.exit(1)
if client_weave_id is None:
emsg = "Could not find Weave node ID of the client node."
self.logger.error("[localhost] WeaveWdmNext: %s" % emsg)
sys.exit(1)
self.clients_info.append({
"client":
client,
"client_node_id":
client_node_id,
"client_ip":
client_ip,
"client_weave_id":
client_weave_id,
"client_process_tag":
client + "_" + self.client_process_tag
})
if self.wdm_option == "view":
self.wdm_client_option = " --wdm-simple-view-client"
self.wdm_server_option = " --wdm-simple-view-server"
print("view disabled")
sys.exit(1)
elif self.wdm_option == "one_way_subscribe":
self.wdm_client_option = " --wdm-one-way-sub-client"
self.wdm_server_option = " --wdm-one-way-sub-publisher"
elif self.wdm_option == "mutual_subscribe":
self.wdm_client_option = " --wdm-init-mutual-sub"
self.wdm_server_option = " --wdm-resp-mutual-sub"
elif self.wdm_option == "subless_notify":
self.wdm_client_option = " --wdm-simple-subless-notify-client"
self.wdm_server_option = " --wdm-simple-subless-notify-server"
else:
emsg = "NOT SUPPORTED WDM OPTION"
self.logger.error("[localhost] WeaveWdmNext: %s" % emsg)
sys.exit(1)
def __pre_check(self):
device_node_id = None
# Set the produce resource that mock-device is paired to
resourceDictionaries = self.getResourceIds()
resourceIndexList = os.environ.get("RESOURCE_IDS", "thd1").split(" ")
self.resources = [
resourceDictionaries[resourceIndex]
for resourceIndex in resourceIndexList
]
# Check if Weave Pairing device node is given.
if self.devices is None:
emsg = "Missing name or address of the Weave Pairing device node."
self.logger.error("[localhost] WeavePairing: %s" % (emsg))
sys.exit(1)
# Check if Weave Pairing mobile node is given.
if self.mobile is None:
emsg = "Missing name or address of the Weave Pairing mobile node."
self.logger.error("[localhost] WeavePairing: %s" % (emsg))
sys.exit(1)
# Check if Weave Pairing server info is given.
if self.server is None:
emsg = "Missing name or address of the Weave Pairing server node."
self.logger.error("[localhost] WeavePairing: %s" % (emsg))
sys.exit(1)
# Make sure that fabric was created
if self.getFabricId() == None:
emsg = "Weave Fabric has not been created yet."
self.logger.error("[localhost] WeavePairing: %s" % (emsg))
sys.exit(1)
# Check if Weave Pairing mobile node exists.
if self._nodeExists(self.mobile):
self.mobile_node_id = self.mobile
# Check if mobile is provided in a form of IP address
if IP.isIpAddress(self.mobile):
self.mobile_node_id = self.getNodeIdFromAddress(self.mobile)
if self.mobile_node_id is None:
emsg = "Unknown identity of the mobile node."
self.logger.error("[localhost] WeavePairing: %s" % (emsg))
sys.exit(1)
# Find out whether to use a local mock server or a server
# reachable over the internet
if self._nodeExists(self.server):
self.server_node_id = self.server
self.server_ip = self.getNodeWeaveIPAddress(self.server_node_id)
self.server_weave_id = self.getWeaveNodeID(self.server_node_id)
elif IP.isIpAddress(self.server):
self.server_ip = self.server
self.server_weave_id = self.IPv6toWeaveId(self.server)
elif IP.isDomainName(self.server) or self.server == "service":
self.server_ip = self.getServiceWeaveIPAddress(
"ServiceProvisioning")
self.server_weave_id = self.IPv6toWeaveId(self.server_ip)
self.mobile_ip = self.getNodeWeaveIPAddress(self.mobile_node_id)
self.mobile_weave_id = self.getWeaveNodeID(self.mobile_node_id)
for device, resource in zip(self.devices, self.resources):
# Check if Weave Pairing device node exists.
if self._nodeExists(device):
device_node_id = device
# Check if device is provided in a form of IP address
if IP.isIpAddress(device):
device_node_id = self.getNodeIdFromAddress(device)
if device_node_id is None:
emsg = "Unknown identity of the device node."
self.logger.error("[localhost] WeavePairing: %s" % (emsg))
sys.exit(1)
device_ip = self.getNodeWeaveIPAddress(device_node_id)
if device_ip is None:
emsg = "Could not find IP address of the device node."
self.logger.error("[localhost] WeavePairing: %s" % (emsg))
sys.exit(1)
device_weave_id = self.getWeaveNodeID(device_node_id)
if device_weave_id is None:
emsg = "Could not find Weave node ID of the device node."
self.logger.error("[localhost] WeavePairing: %s" % (emsg))
sys.exit(1)
device_serial_num = self.getSerialNum(device_node_id)
if device_serial_num is None:
emsg = "Could not find serial number of the device node."
self.logger.error("[localhost] WeavePairing: %s" % (emsg))
sys.exit(1)
self.devices_info.append({
'device':
device,
'device_node_id':
device_node_id,
'device_ip':
device_ip,
'device_weave_id':
device_weave_id,
'device_serial_num':
device_serial_num,
'device_process_tag':
device + "_" + self.device_process_tag,
'resource':
resource
})
if self.mobile_ip is None:
emsg = "Could not find IP address of the mobile node."
self.logger.error("[localhost] WeavePairing: %s" % (emsg))
sys.exit(1)
if self.mobile_weave_id is None:
emsg = "Could not find Weave node ID of the mobile node."
self.logger.error("[localhost] WeavePairing: %s" % (emsg))
sys.exit(1)
if self.server_ip is None:
emsg = "Could not find IP address of the server."
self.logger.error("[localhost] WeavePairing: %s" % (emsg))
sys.exit(1)
if self.server_weave_id is None:
emsg = "Could not find Weave node ID of the server."
self.logger.error("[localhost] WeavePairing: %s" % (emsg))
sys.exit(1)
def __pre_check(self):
# Check if Weave SWU client node is given.
if self.client == None:
emsg = "Missing name or address of the Weave SWU client node."
self.logger.error("[localhost] WeaveSWU: %s" % (emsg))
sys.exit(1)
# Check if Weave SWU server node is given.
if self.server == None:
emsg = "Missing name or address of the Weave SWU server node."
self.logger.error("[localhost] WeaveSWU: %s" % (emsg))
sys.exit(1)
# Make sure that fabric was created
if self.getFabricId() == None:
emsg = "Weave Fabric has not been created yet."
self.logger.error("[localhost] WeaveSWU: %s" % (emsg))
sys.exit(1)
# Check if Weave SWU client node exists.
if self._nodeExists(self.client):
self.client_node_id = self.client
# Check if Weave SWU server node exists.
if self._nodeExists(self.server):
self.server_node_id = self.server
# Check if client is provided in a form of IP address
if IP.isIpAddress(self.client):
self.client_node_id = self.getNodeIdFromAddress(self.client)
# Check if server is provided in a form of IP address
if IP.isIpAddress(self.server):
self.server_node_id = self.getNodeIdFromAddress(self.server)
if self.client_node_id == None:
emsg = "Unknown identity of the client node."
self.logger.error("[localhost] WeaveSWU: %s" % (emsg))
sys.exit(1)
if self.server_node_id == None:
emsg = "Unknown identity of the server node."
self.logger.error("[localhost] WeaveSWU: %s" % (emsg))
sys.exit(1)
self.client_ip = self.getNodeWeaveIPAddress(self.client_node_id)
self.server_ip = self.getNodeWeaveIPAddress(self.server_node_id)
self.client_weave_id = self.getWeaveNodeID(self.client_node_id)
self.server_weave_id = self.getWeaveNodeID(self.server_node_id)
# Check if all unknowns were found
if self.client_ip == None:
emsg = "Could not find IP address of the client node."
self.logger.error("[localhost] WeaveSWU: %s" % (emsg))
sys.exit(1)
if self.server_ip == None:
emsg = "Could not find IP address of the server node."
self.logger.error("[localhost] WeaveSWU: %s" % (emsg))
sys.exit(1)
if self.client_weave_id == None:
emsg = "Could not find Weave node ID of the client node."
self.logger.error("[localhost] WeaveSWU: %s" % (emsg))
sys.exit(1)
if self.server_weave_id == None:
emsg = "Could not find Weave node ID of the server node."
self.logger.error("[localhost] WeaveSWU: %s" % (emsg))
sys.exit(1)
# Check file_designator,update_scheme,integrity_type
if self.integrity_type == None:
emsg = "Missing integrity type that is used by SWU server."
self.logger.error("[localhost] WeaveSWU: %s" % (emsg))
sys.exit(1)
if self.update_scheme == None:
emsg = "Missing update scheme that is used by SWU server."
self.logger.error("[localhost] WeaveSWU: %s" % (emsg))
sys.exit(1)
if self.file_designator == None:
emsg = "Missing path to a temporaty directory that is used by SWU server."
self.logger.error("[localhost] WeaveSWU: %s" % (emsg))
sys.exit(1)
if self.integrity_type != None:
self.integrity_type = str(self.integrity_type)
if not self.integrity_type.isdigit():
emsg = "File integrity type must be a number, not %s." % (self.integrity_type)
self.logger.error("[localhost] WeaveSWU: %s" % (emsg))
if int(self.integrity_type) not in [0, 1, 2]:
emsg = "File integrity type must be 0, or 1, or 2, not %s." % (self.integrity_type)
self.logger.error("[localhost] WeaveSWU: %s" % (emsg))
sys.exit(1)
if self.update_scheme != None:
self.update_scheme = str(self.update_scheme)
if not self.update_scheme.isdigit():
emsg = "File update scheme must be a number, not %s." % (self.update_scheme)
self.logger.error("[localhost] WeaveSWU: %s" % (emsg))
if int(self.update_scheme) not in [0, 1, 2, 3]:
emsg = "File update scheme must be 0, or 1, or 2, or 3 not %s." % (self.update_scheme)
self.logger.error("[localhost] WeaveSWU: %s" % (emsg))
sys.exit(1)
def __pre_check(self):
# Check if Weave DEVICE-DESCRIPTION client node is given.
if self.client == None:
emsg = "Missing name or address of the Weave DEVICE-DESCRIPTION client node."
self.logger.error("[localhost] WeaveDeviceDescription: %s" %
(emsg))
sys.exit(1)
# Check if Weave DEVICE-DESCRIPTION server node is given.
if self.server == None:
emsg = "Missing name or address of the Weave DEVICE-DESCRIPTION server node."
self.logger.error("[localhost] WeaveDeviceDescription: %s" %
(emsg))
sys.exit(1)
# Make sure that fabric was created
if self.getFabricId() == None:
emsg = "Weave Fabric has not been created yet."
self.logger.error("[localhost] WeaveDeviceDescription: %s" %
(emsg))
sys.exit(1)
# Check if Weave DEVICE-DESCRIPTION client node exists.
if self._nodeExists(self.client):
self.client_node_id = self.client
# Check if Weave DEVICE-DESCRIPTION server node exists.
if self._nodeExists(self.server):
self.server_node_id = self.server
# Check if client is provided in a form of IP address
if IP.isIpAddress(self.client):
self.client_node_id = self.getNodeIdFromAddress(self.client)
# Check if server is provided in a form of IP address
if IP.isIpAddress(self.server):
self.server_node_id = self.getNodeIdFromAddress(self.server)
if self.client_node_id == None:
emsg = "Unknown identity of the client node."
self.logger.error("[localhost] WeaveDeviceDescription: %s" %
(emsg))
sys.exit(1)
if self.server_node_id == None:
emsg = "Unknown identity of the server node."
self.logger.error("[localhost] WeaveDeviceDescription: %s" %
(emsg))
sys.exit(1)
self.client_ip = self.getNodeWeaveIPAddress(self.client_node_id)
self.server_ip = self.getNodeWeaveIPAddress(self.server_node_id)
self.client_weave_id = self.getWeaveNodeID(self.client_node_id)
self.server_weave_id = self.getWeaveNodeID(self.server_node_id)
# Check if all unknowns were found
if self.client_ip == None:
emsg = "Could not find IP address of the client node."
self.logger.error("[localhost] WeaveDeviceDescription: %s" %
(emsg))
sys.exit(1)
if self.server_ip == None:
emsg = "Could not find IP address of the server node."
self.logger.error("[localhost] WeaveDeviceDescription: %s" %
(emsg))
sys.exit(1)
if self.client_weave_id == None:
emsg = "Could not find Weave node ID of the client node."
self.logger.error("[localhost] WeaveDeviceDescription: %s" %
(emsg))
sys.exit(1)
if self.server_weave_id == None:
emsg = "Could not find Weave node ID of the server node."
self.logger.error("[localhost] WeaveDeviceDescription: %s" %
(emsg))
sys.exit(1)
def __pre_check(self):
if self.border_gateway:
if self.border_gateway != self.getTunnelGatewayNodeId():
emsg = "Incorrect border-gateway node id. Entered %s vs %s on the record." % \
(self.border_gateway, self.getTunnelGatewayNodeId())
self.logger.error("[localhost] WeaveTunnelStart: %s" % (emsg))
self.exit()
else:
self.border_gateway = self.getTunnelGatewayNodeId()
# Check if border-gateway node was given
if not self.border_gateway:
emsg = "Border-gateway node id not specified and there is none on the record."
self.logger.error("[localhost] WeaveTunnelStart: %s" % (emsg))
self.exit()
if not self._nodeExists(self.border_gateway):
emsg = "Border-gateway node %s does not exist." % (
self.border_gateway)
self.logger.error("[localhost] WeaveTunnelStart: %s" % (emsg))
self.exit()
# Check if service node was given in the environment
if not self.service:
self.service = self.getTunnelServiceNodeId()
if not self.service and self.service_dir:
if self.service_dir_server:
self.skip_service_end = True
self.logger.debug(
"[localhost] WeaveTunnelStart against tier %s." %
self.service_dir_server)
else:
self.service_dir_server = self.getTunnelServiceDir()
if not self.service_dir_server:
# Check if service node was given
emsg = "Service node id (or IP address or service directory) not specified."
self.logger.error("[localhost] WeaveTunnelStart: %s" %
(emsg))
self.exit()
else:
self.skip_service_end = True
self.logger.debug(
"[localhost] WeaveTunnelStart against tier %s." %
self.service_dir_server)
if self.service:
# If service is a domain name, convert it to IP
if IP.isDomainName(self.service):
ip = IP.getHostByName(self.service)
self.service = ip
if not IP.isIpAddress(self.service):
if self.service:
if self.service != self.getTunnelServiceNodeId():
emsg = "Incorrect service node id. Entered %s vs %s on the record." % \
(self.service, self.getTunnelServiceNodeId())
self.logger.error("[localhost] WeaveTunnelStart: %s" %
(emsg))
self.exit()
if not IP.isIpAddress(self.service) and not self._nodeExists(
self.service):
emsg = "Service node %s does not exist." % (self.service)
self.logger.error("[localhost] WeaveTunnelStart: %s" % (emsg))
self.exit()
if IP.isIpAddress(self.service):
self.skip_service_end = True
# Check if there is no fabric
if not self.getFabricId():
emsg = "There is not Weave fabric."
self.logger.error("[localhost] WeaveTunnelStart: %s" % (emsg))
self.exit()
# Check if there is a tunnel
if not self.getTunnelServiceNodeId() and not self.getTunnelServiceDir(
):
emsg = "There is no Weave tunnel on the record."
self.logger.error("[localhost] WeaveTunnelStart: %s" % (emsg))
self.exit()
def __pre_check(self):
# Check if border-gateway node was given
if not self.border_gateway:
emsg = "Border-gateway node id not specified."
self.logger.error("[localhost] WeaveTunnelStart: %s" % (emsg))
self.exit()
if not self._nodeExists(self.border_gateway):
emsg = "Border-gateway node %s does not exist." % (
self.border_gateway)
self.logger.error("[localhost] WeaveTunnelStart: %s" % (emsg))
self.exit()
# Check if service node was given in the environment
if not self.service and not self.service_dir:
if "weave_service_address" in os.environ.keys():
self.service = os.environ['weave_service_address']
emsg = "Found weave_service_address %s." % (self.service)
self.logger.debug("[localhost] Weave: %s" % (emsg))
if not self.service and self.service_dir:
if self.service_dir_server:
self.skip_service_end = True
self.logger.debug(
"[localhost] WeaveTunnelStart against tier %s." %
self.service_dir_server)
else:
if "weave_service_address" in os.environ.keys():
self.skip_service_end = True
self.service_dir_server = os.environ[
'weave_service_address']
self.logger.debug(
"[localhost] WeaveTunnelStart against tier %s." %
self.service_dir_server)
else:
# Check if service node was given
emsg = "Service node id (or IP address or service directory) not specified."
self.logger.error("[localhost] WeaveTunnelStart: %s" %
(emsg))
self.exit()
if self.service and not self.use_lwip:
# If service is a domain name, convert it to IP
if IP.isDomainName(self.service):
ip = IP.getHostByName(self.service)
self.service = ip
if not IP.isIpAddress(self.service) and not self._nodeExists(
self.service):
emsg = "Service node %s does not exist." % (self.service)
self.logger.error("[localhost] WeaveTunnelStart: %s" % (emsg))
self.exit()
if IP.isIpAddress(self.service):
self.service_ipv4_addr = self.service
self.skip_service_end = True
else:
self.service_ipv4_addr = self.getNodePublicIPv4Address(
self.service)
if self.service_ipv4_addr == None:
emsg = "Could not find IP address of the service node."
self.logger.error("[localhost] WeaveTunnel: %s" % (emsg))
self.exit()
self.fabric_id = self.getFabricId()
# Check if there is no fabric
if self.fabric_id == None:
emsg = "There is not Weave fabric."
self.logger.error("[localhost] WeaveTunnelStart: %s" % (emsg))
self.exit()
# Check if there is a tunnel
if self.getTunnelServiceNodeId() or self.getTunnelServiceDir():
emsg = "There already exist a Weave tunnel."
self.logger.error("[localhost] WeaveTunnelStart: %s" % (emsg))
self.__stopExistingTunnel()
self.service_weave_id = self.getServiceWeaveID("Tunnel")
self.gateway_weave_id = self.getWeaveNodeID(self.border_gateway)
if self.service_weave_id == None:
emsg = "Could not find Weave node ID of the service node."
self.logger.error("[localhost] WeaveTunnel: %s" % (emsg))
self.exit()
if self.gateway_weave_id == None:
emsg = "Could not find Weave node ID of the border-gateway node."
self.logger.error("[localhost] WeaveTunnel: %s" % (emsg))
self.exit()
