def data_init(nodes_file, matrix_file):
""" 从文件读入网络数据 """
# 读取节点信息
node_list = []
node_name = {}
node_pos = {}
with open(nodes_file) as fn:
reader = csv.reader(fn)
next(reader)
for i, line in enumerate(reader):
node_name[line[0]] = i
node_list.append(ni.Node(i, int(line[3]), float(line[4])))
node_pos[i] = np.array([float(line[1]), float(line[2])])
# 读取网络信息
bandwidth = [[0 for col in range(len(node_name))]
for row in range(len(node_name))]
adj = [[0 for col in range(len(node_name))]
for row in range(len(node_name))]
with open(matrix_file) as fm:
reader = csv.reader(fm)
next(reader)
for i, line in enumerate(reader):
bandwidth[node_name[line[1]]][node_name[line[2]]] = int(line[3])
bandwidth[node_name[line[2]]][node_name[line[1]]] = int(line[3])
adj[node_name[line[1]]][node_name[line[2]]] = 1
adj[node_name[line[2]]][node_name[line[1]]] = 1
return node_list, bandwidth, adj, node_pos
def getStaticInfo(self):
staticInformation = {}
try:
staticInformation["MAC Address"] = NetworkInfo.getMAC()
except:
pass
try:
cpuInfo = CPUInfo.getCPUInfo()
staticInformation["Serial Number"] = cpuInfo['Serial'][0]
staticInformation["Hardware"] = cpuInfo['Hardware'][0]
staticInformation[
"Manufacturer"] = ManufatcurerInfo.getManufaturerInfo(
cpuInfo["Revision"][0])
except Exception as e:
pass
try:
osInfo = OSInfo.getOSInfo()
staticInformation["OS"] = {}
staticInformation["Hostname"] = osInfo["Hostname"]
staticInformation["OS"]["Name"] = osInfo["NAME"]
staticInformation["OS"]["Type"] = osInfo["ID_LIKE"]
staticInformation["OS"]["Version Number"] = osInfo["VERSION_ID"]
staticInformation["OS"]["Architecture"] = osInfo["Architecture"]
staticInformation["OS"]["Version"] = osInfo["OS Version"]
staticInformation["OS"]["Release"] = osInfo["OS Release"]
except Exception as e:
pass
return staticInformation
def add_instance(bandwidth, node_list, instance_registry, instance_num, request, request_placement, nf_index):
""" 为指定nf增加一个实例 """
# 找距离前驱和后继Node距离之和最小的Node
vector = get_placement_vector(request, request_placement)
pre_nodes = vector[nf_index]
post_nodes = vector[nf_index + 2]
candidate_nodes_distance = [[i, 0] for i in range(len(node_list))]
for v in range(len(node_list)):
distance_sum = 0
for pre in pre_nodes:
distance_sum += distance(bandwidth, pre, v)
for post in post_nodes:
distance_sum += distance(bandwidth, v, post)
candidate_nodes_distance[v][1] = distance_sum
# 排除已有同类实例的Node
for u in vector[nf_index + 1]:
candidate_nodes_distance[u][1] = float("inf")
# 按照距离远近排序
candidate_nodes_distance = sorted(sorted(candidate_nodes_distance, key=lambda n: node_list[n[0]].avail, reverse=True), key=lambda n: n[1])
candidate_nodes = [n[0] for n in candidate_nodes_distance]
nf_id = request.nf_list[nf_index]
for v in candidate_nodes:
# 如果已经有同类实例，且capacity还有剩余
same_instance = None
for instance in node_list[v].instances:
if instance.type == nf_id and instance.capacity > 0:
same_instance = instance
if same_instance is not None:
# 在表中登记这个新实例
request_placement[request.id][nf_index][v] = same_instance
break
elif node_list[v].CPU > Global.NF_CPU_REQUIREMENT[nf_id] and v not in vector[nf_index + 1]:
# 在request_placement中部署
new_instance = ni.Instance(instance_num[nf_id], nf_id)
instance_num[nf_id] += 1
new_instance.placement = v
request_placement[request.id][nf_index][v] = new_instance
instance_registry[nf_id].append(new_instance)
# 更新Node
node_list[v].CPU -= Global.NF_CPU_REQUIREMENT[nf_id]
node_list[v].instances.append(new_instance)
break
# 没有满足资源需求的Node了
else:
raise AssertionError("No CPU to satisfy Availability!")
def get_requests(request_num, nf_list_length, rate, avail):
""" 随机生成请求集合 """
request_list = []
src_list = [1, 34, 37, 31, 3, 11, 8, 40, 32]
dst_list = [36, 48, 0, 29, 28, 46, 24, 38]
for i in range(request_num):
r = ni.Request(
i, random.choice(src_list), random.choice(dst_list),
random.sample(range(Global.NF_TYPE_NUM),
random.randint(nf_list_length[0],
nf_list_length[1])),
random.randint(rate[0], rate[1]),
random.uniform(avail[0], avail[1]))
request_list.append(r)
return request_list
import SystemDrives as sd
import OsInfo as oi
import NetworkInfo as ni
import SoftwareInfo as si
print('{:*^65s}'.format('Operating System Information'))
o1 = oi.OsInfo()
for i in o1.Osinfo().items():
print('{}:{}'.format(i[0], i[1]))
print('\n\n{:*^65s}'.format('Drives On System'))
s1 = sd.SystemDrives()
for s in s1.GetDrives():
print('{}'.format(s))
print('\n\n{:*^65s}'.format('Network Information'))
n1 = ni.NetworkInfo()
for i in n1.networkinfo().items():
print('{}:{}'.format(i[0], i[1]))
print('\n\n{:*^65s}'.format('Installed Software'))
s1 = si.SoftwareInfo()
i = 1
print('{} Softwares installed'.format(s1.softwareinfo()['count']))
for s in s1.softwareinfo()['lists']:
print(s)
def extend_deploy(bandwidth_origin, node_list, request_list):
""" 扩展部署算法 """
# 剩余带宽矩阵
bandwidth = copy.copy(bandwidth_origin)
# 储存每个请求的带宽消耗矩阵
flow_matrix_request = {}
# 实例注册表(每种NF一个子表)
instance_registry = [[] for i in range(Global.NF_TYPE_NUM)]
# 每个请求选择的部署位置
request_placement = []
# 每个类型nf实例个数
instance_num = [0] * Global.NF_TYPE_NUM
# 初始化 request_placement, 并将请求排序(按照流量速率/可用性要求)
# TODO：排序依据加上NF表长度
rate_sum = sum(request.rate for request in request_list)
avail_max = max(request.avail for request in request_list)
avail_min = min(request.avail for request in request_list)
for r in request_list:
request_placement.append([{} for nf in r.nf_list])
if avail_max == avail_min:
r.rank = r.rate / float(rate_sum)
else:
r.rank = r.rate / float(rate_sum) + (r.avail - avail_min) / (
avail_max - avail_min)
request_list = sorted(request_list, key=lambda r: r.rank, reverse=True)
""" 依次部署请求 """
for request in request_list:
# 找离源点和汇点最近的Node
candidate_nodes_distance = []
for v in range(len(node_list)):
candidate_nodes_distance.append(
(v, util.distance(bandwidth, request.src, v) +
util.distance(bandwidth, v, request.dst)))
candidate_nodes_distance = sorted(sorted(
candidate_nodes_distance,
key=lambda n: node_list[n[0]].avail,
reverse=True),
key=lambda n: n[1])
# 按照距离源汇点距离之和远近进行排序后的Node表
candidate_nodes = [n[0] for n in candidate_nodes_distance]
""" 对每个要部署的nf（第i个）放置第一个实例 """
for i, nf in enumerate(request.nf_list):
# 在候选表中依次选择
for v in candidate_nodes:
# 如果已经有同类实例，且capacity还有剩余
same_instance = None
for instance in node_list[v].instances:
if instance.type == nf and instance.capacity > 0:
same_instance = instance
if same_instance is not None:
# 在表中登记这个新实例
request_placement[request.id][i][v] = same_instance
break
# 如果没有同类实例
elif node_list[v].CPU > Global.NF_CPU_REQUIREMENT[nf]:
# 新建一个实例，并放置在当前Node
new_instance = ni.Instance(instance_num[nf], nf)
instance_num[nf] += 1
new_instance.placement = v
# 在两个表中登记这个新实例
request_placement[request.id][i][v] = new_instance
instance_registry[nf].append(new_instance)
# 更新Node
node_list[v].CPU -= Global.NF_CPU_REQUIREMENT[nf]
node_list[v].instances.append(new_instance)
break
# 没有满足资源需求的Node了
else:
raise AssertionError("No CPU!")
# 计算可用性
avail_bottleneck_index = util.get_avail(request, node_list,
request_placement)
# 所有使用的实例剩余capacity总和
capacity_bottleneck_index = util.get_rest_capacity(
request, request_placement)
# 可用性拉满
while (1):
# 如果可用性不足
if avail_bottleneck_index > -1:
util.add_instance(bandwidth, node_list, instance_registry,
instance_num, request, request_placement,
avail_bottleneck_index)
# 计算可用性
avail_bottleneck_index = util.get_avail(
request, node_list, request_placement)
else:
break
# 剩余capacity拉满
while (1):
# 如果capacity不足
if capacity_bottleneck_index > -1:
util.add_instance(bandwidth, node_list, instance_registry,
instance_num, request, request_placement,
capacity_bottleneck_index)
# 计算可用性
capacity_bottleneck_index = util.get_rest_capacity(
request, request_placement)
else:
break
""" 根据部署位置计算链的网络流 """
flow_matrix = util.get_route(bandwidth, request, request_placement)
flow_matrix_request[request.id] = flow_matrix
bandwidth = (np.mat(bandwidth) - np.mat(flow_matrix)).tolist()
""" 部署完毕 """
return request_placement, instance_num, bandwidth, flow_matrix_request
return cost
if __name__ == "__main__":
bandwidth = [[0, 100, 0, 0, 100, 0, 100, 0],
[100, 0, 100, 0, 100, 100, 0, 0],
[0, 100, 0, 100, 100, 0, 0, 0],
[0, 0, 100, 0, 0, 100, 0, 100],
[100, 100, 100, 0, 0, 100, 100, 0],
[0, 100, 0, 100, 100, 0, 100, 100],
[100, 0, 0, 0, 100, 100, 0, 100],
[0, 0, 0, 100, 0, 100, 100, 0]]
node_list = [
ni.Node(0, 100, 0.9),
ni.Node(1, 100, 0.9),
ni.Node(2, 100, 0.9),
ni.Node(3, 100, 0.9),
ni.Node(4, 100, 0.9),
ni.Node(5, 100, 0.9),
ni.Node(6, 100, 0.8),
ni.Node(7, 100, 0.8),
]
request_list = [
ni.Request(0, 0, 7, [1, 2, 3], 20, 0.95),
ni.Request(1, 0, 3, [2, 3], 15, 0.9)
]
# d = distance(bandwidth, 0, 3)
def random_deploy(bandwidth_origin, node_list, request_list):
""" 随机部署算法 """
# 剩余带宽矩阵
bandwidth = copy.copy(bandwidth_origin)
# 储存每个请求的带宽消耗矩阵
flow_matrix_request = {}
# 实例注册表(每种NF一个子表)
instance_registry = [[] for i in range(Global.NF_TYPE_NUM)]
# 每个请求选择的部署位置
request_placement = []
for r in request_list:
request_placement.append([{} for nf in r.nf_list])
# 每个类型nf实例个数
instance_num = [0] * Global.NF_TYPE_NUM
""" 依次部署请求 """
for request in request_list:
# 依次部署请求中的nf
for i, nf in enumerate(request.nf_list):
# 随机选择一个点
sample_node = random.sample(range(len(node_list)), len(node_list))
# 直到满足资源需求
for v in sample_node:
if node_list[v].CPU > Global.NF_CPU_REQUIREMENT[nf]:
# 新建一个实例，并放置在当前Node
new_instance = ni.Instance(instance_num[nf], nf)
instance_num[nf] += 1
new_instance.placement = v
# 在两个表中登记这个新实例
request_placement[request.id][i][v] = new_instance
instance_registry[nf].append(new_instance)
# 更新Node
node_list[v].CPU -= Global.NF_CPU_REQUIREMENT[nf]
node_list[v].instances.append(new_instance)
break
# 没有满足资源需求的Node了
else:
raise AssertionError("No CPU!")
# 计算可用性
avail_bottleneck_index = util.get_avail(request, node_list,
request_placement)
# 所有使用的实例剩余capacity总和
capacity_bottleneck_index = util.get_rest_capacity(
request, request_placement)
# 可用性和剩余capacity拉满
while avail_bottleneck_index > -1 or capacity_bottleneck_index > -1:
if avail_bottleneck_index > -1:
bottleneck_index = avail_bottleneck_index
elif capacity_bottleneck_index > -1:
bottleneck_index = capacity_bottleneck_index
else:
break
# placed_nodes = request_placement[request.id][bottleneck_index].keys()
# # 随机选择一个点
# sample_node = random.sample(range(len(node_list)), len(node_list))
# # 直到满足资源需求
# for v in sample_node:
# if v not in placed_nodes:
# # 如果已经有同类实例，且capacity还有剩余
# same_instance = None
# for instance in node_list[v].instances:
# if instance.type == nf and instance.capacity > 0:
# same_instance = instance
# if same_instance is not None:
# # 在表中登记这个新实例
# request_placement[request.id][bottleneck_index][v] = same_instance
# break
#
# # 如果没有同类实例
# elif node_list[v].CPU > Global.NF_CPU_REQUIREMENT[nf]:
# # 新建一个实例，并放置在当前Node
# new_instance = ni.Instance(instance_num[nf], nf)
# instance_num[nf] += 1
# new_instance.placement = v
# # 在两个表中登记这个新实例
# request_placement[request.id][bottleneck_index][v] = new_instance
# instance_registry[nf].append(new_instance)
# # 更新Node
# node_list[v].CPU -= Global.NF_CPU_REQUIREMENT[nf]
# node_list[v].instances.append(new_instance)
# break
#
# # 没有满足资源需求的Node了
# else:
# raise AssertionError("No CPU!")
""" 增加实例时随机选点有bug，暂时使用更优的部分extend策略 """
util.add_instance(bandwidth, node_list, instance_registry,
instance_num, request, request_placement,
bottleneck_index)
# 计算可用性和剩余capacity
avail_bottleneck_index = util.get_avail(request, node_list,
request_placement)
capacity_bottleneck_index = util.get_rest_capacity(
request, request_placement)
""" 根据部署位置计算链的网络流 """
flow_matrix = util.get_route(bandwidth, request, request_placement)
flow_matrix_request[request.id] = flow_matrix
bandwidth = (np.mat(bandwidth) - np.mat(flow_matrix)).tolist()
""" 部署完毕 """
return request_placement, instance_num, bandwidth, flow_matrix_request
from HeartBeat import HeartBeat
import NetworkInfo
import time
# Get Network Settings
current_hostname, current_ip, current_broadcast = NetworkInfo.get_network_info(
)
port = 50002
print("\n", "+-------------------------------+", "\n",
"| Network Settings |", "\n",
"+-------------------------------+", "\n", "| IP Address = ", current_ip,
"\n", "| Broadcast = ", current_broadcast, "\n", "| Port = ",
port, "\n", "+-------------------------------+", "\n")
current_ip = input(
'Press enter to start the node or enter an ip address manually:'
) or current_ip
continue_flag = "continue"
# Initialize Node
while continue_flag != "exit":
node = HeartBeat(name=current_hostname,
ip=current_ip,
broadcast=current_broadcast,
port=port,
heartbeat_interval=2,
ttl=2,
debug=False)
## Start Node
print("Starting Node ...\n")
#while continue_flag:
try:
node.start()
def __init__(self):
self.net = NetworkInfo.NetInfo()
self.disk = DiskInfo.DiskInfo()
self.cpu = CpuInfo.CpuInfo()