class Scheduler(object):
event_chief = EventChief()
def __init__(self, xml_net_num, sching_logto):
logging.basicConfig(level=logging.DEBUG)
self.sching_logto = sching_logto
if is_scheduler_run:
self.xml_parser = XMLParser("net_2p_stwithsingleitr.xml", str(xml_net_num))
else:
self.xml_parser = XMLParser("ext/net_2p_stwithsingleitr.xml", str(xml_net_num))
self.gm = GraphMan()
self.init_network_from_xml()
#Useful state variables
self.last_sching_id_given = -1
self.last_sch_req_id_given = -1
self.last_tp_dst_given = info_dict['base_sport']-1
#Scher state dicts
self.num_dstusers = 0
self.users_beingserved_dict = {} #user_ip:{'gw_dpid':<>,'gw_conn_port':<> ...}
#
self.N = 0 #num_activesessions
self.alloc_dict = None
self.sessions_beingserved_dict = {}
self.sessions_pre_served_dict = {}
self.sid_res_dict = {}
self.actual_res_dict = self.gm.give_actual_resource_dict()
#for perf plotting
self.perf_plotter = PerfPlotter(self.actual_res_dict)
#for control_comm
self.cci = ControlCommIntf()
self.cci.reg_commpair(sctag = 'scher-acter',
proto = 'tcp',
_recv_callback = self._handle_recvfromacter,
s_addr = info_dict['lacter_addr'],
c_addr = info_dict['acterl_addr'] )
######################### _handle_*** methods #######################
def _handle_recvfromacter(self, msg):
#msg = [type_, data_]
[type_, data_] = msg
if type_ == 'sp_sching_reply':
s_id, p_id = int(data_['s_id']), int(data_['p_id'])
reply = data_['reply']
if reply == 'done':
#updating global dicts
self.sessions_beingserved_dict[s_id]['sching_job_done'][p_id] = True
#get s_alloc_info
s_alloc_info = self.alloc_dict['s-wise'][s_id]
s_pl = s_alloc_info['parism_level']
#get s_info, dtsuserinfo
s_info = self.sessions_beingserved_dict[s_id]
p_ip = s_info['p_c_ip_list'][0]
user_info = self.users_beingserved_dict[p_ip]
info_dict = {'ip': p_ip,
'mac': user_info['mac'],
'gw_dpid': user_info['gw_dpid'],
'gw_conn_port': user_info['gw_conn_port'] }
msg = json.dumps({'type':'sching_reply',
'data':{'parism_level':s_pl,
'p_bw':s_alloc_info['p_bw'][0:s_pl],
'p_tp_dst':s_info['tp_dst_list'][0:s_pl] } })
#fire send_sching_reply to the user
Scheduler.event_chief.raise_event('send_msg_to_user',msg,info_dict)
else:
logging.error('Unexpected reply=%s', reply)
def _handle_recvfromdtsuser(self, msg, dtsuserinfo_dict):
msg_ = check_msg('recv', 'dts-user', msg)
if msg_ == None:
print 'msg is not proto-good'
return
#msg_ = [type_, data_]
[type_, data_] = msg_
#
src_ip = dtsuserinfo_dict['src_ip']
src_mac = dtsuserinfo_dict['src_mac']
src_gw_dpid = dtsuserinfo_dict['src_gw_dpid']
src_gw_conn_port = dtsuserinfo_dict['src_gw_conn_port']
info_dict = {'ip': src_ip,
'mac': src_mac,
'gw_dpid': src_gw_dpid,
'gw_conn_port': src_gw_conn_port}
if type_ == 'join_req':
if self.welcome_user(user_ip = src_ip,
user_mac = src_mac,
gw_dpid = src_gw_dpid,
gw_conn_port = src_gw_conn_port ):
msg = json.dumps({'type':'join_reply',
'data':'welcome' })
Scheduler.event_chief.raise_event('send_msg_to_user',msg,info_dict)
else: #fire send_neg_reply to the user
msg = json.dumps({'type':'join_reply',
'data':'sorry' })
Scheduler.event_chief.raise_event('send_msg_to_user',msg,info_dict)
elif type_ == 'sching_req':
if self.welcome_session(p_c_ip_list = [src_ip, data_['c_ip']],
req_dict = data_['req_dict'],
app_pref_dict = data_['app_pref_dict'] ):
#TODO: for now ...
self.do_sching()
else: #fire send_neg_reply to the user
msg = json.dumps({'type':'sching_reply',
'data':'sorry' })
Scheduler.event_chief.raise_event('send_msg_to_user',msg,info_dict)
#################### scher_state_management methods #######################
def print_scher_state(self):
print '<---------------------------------------->'
print 'is_scheduler_run: ', is_scheduler_run
print 'users_beingserved_dict:'
pprint.pprint(self.users_beingserved_dict)
print 'sessions_beingserved_dict:'
pprint.pprint(self.sessions_beingserved_dict)
print 'sessions_pre_served_dict:'
pprint.pprint(self.sessions_pre_served_dict)
print '<---------------------------------------->'
def next_sching_id(self):
self.last_sching_id_given += 1
return self.last_sching_id_given
def next_sch_req_id(self):
self.last_sch_req_id_given += 1
return self.last_sch_req_id_given
def next_tp_dst(self):
self.last_tp_dst_given += 1
return self.last_tp_dst_given
def did_user_joindts(self, user_ip):
return user_ip in self.users_beingserved_dict
def welcome_user(self, user_ip, user_mac, gw_dpid, gw_conn_port):
if self.did_user_joindts(user_ip):
print 'user_ip=%s already joined' % user_ip
return False
#
self.users_beingserved_dict.update({user_ip:{'gw_dpid':gw_dpid,
'gw_conn_port':gw_conn_port,
'mac': user_mac } })
print 'welcome user: ip=%s, mac=%s, gw_dpid=%s, gw_conn_port=%s' % (user_ip,user_mac,gw_dpid,gw_conn_port)
return True
#not used now, for future
def bye_user(self, user_ip):
if not self.did_user_joindts(user_ip):
print 'user_ip=%s is not joined' % user_ip
return False
#
del self.users_beingserved_dict[user_ip]
print 'bye user: ip=%s' % user_ip
return True
def welcome_session(self, p_c_ip_list, req_dict, app_pref_dict):
''' sch_req_id: should be unique for every sch_session '''
[p_ip, c_ip] = p_c_ip_list
if not (self.did_user_joindts(p_ip) and self.did_user_joindts(c_ip)):
print 'nonjoined user in sching_req'
return False
#
p_c_gwtag_list = ['s'+str(self.users_beingserved_dict[p_ip]['gw_dpid']),
's'+str(self.users_beingserved_dict[c_ip]['gw_dpid']) ]
#update global var, list and dicts
self.N += 1
s_pl = req_dict['parism_level']
s_tp_dst_list = [self.next_tp_dst() for i in range(0,s_pl)]
sch_req_id = self.next_sch_req_id()
self.sessions_beingserved_dict.update(
{sch_req_id:{'tp_dst_list': s_tp_dst_list,
'p_c_ip_list': p_c_ip_list,
'p_c_gwtag_list': p_c_gwtag_list,
'app_pref_dict': app_pref_dict,
'req_dict': req_dict,
'sching_job_done':[False]*s_pl }
}
)
#print 'self.sessions_beingserved_dict: '
#pprint.pprint(self.sessions_beingserved_dict)
#
return True
def bye_session(self, sch_req_id):
self.N -= 1
# Send sessions whose "sching job" is done is sent to pre_served category
self.sessions_pre_served_dict.update(
{sch_req_id: self.sessions_beingserved_dict[sch_req_id]})
del self.sessions_beingserved_dict[sch_req_id]
def init_network_from_xml(self):
node_edge_lst = self.xml_parser.give_node_and_edge_list_from_xml()
#print 'node_lst:'
#pprint.pprint(node_edge_lst['node_lst'])
#print 'edge_lst:'
#pprint.pprint(node_edge_lst['edge_lst'])
self.gm.graph_add_nodes(node_edge_lst['node_lst'])
self.gm.graph_add_edges(node_edge_lst['edge_lst'])
######################### sching_rel methods ###############################
def update_sid_res_dict(self):
"""
Network resources will be only the ones on the session_shortest path.
It resources need to lie on the session_shortest path.
"""
logging.info('update_sid_res_dict:')
#TODO: sessions whose resources are already specified no need for putting them in the loop
for s_id in self.sessions_beingserved_dict:
p_c_gwdpid_list = self.sessions_beingserved_dict[s_id]['p_c_gwtag_list']
s_all_paths = self.gm.give_all_paths(p_c_gwdpid_list[0], p_c_gwdpid_list[1])
#print out all_paths for debugging
dict_ = {i:p for i,p in enumerate(s_all_paths)}
logging.info('s_id=%s, all_paths=\n%s', s_id, pprint.pformat(dict_))
#
for i,p in dict_.items():
p_net_edge_list = self.gm.pathlist_to_netedgelist(p)
p_itres_list = self.gm.give_itreslist_on_path(p)
if not (s_id in self.sid_res_dict):
self.sid_res_dict[s_id] = {'s_info':{}, 'ps_info':{}}
self.sid_res_dict[s_id]['ps_info'].update(
{i: {'path': p,
'net_edge_list': p_net_edge_list,
'itres_list': p_itres_list
}
})
def do_sching(self):
'''
Currently for active sessions, gets things together to work sching logic and
then sends corresponding walk/itjob rules to correspoding actuator - which is
a single actuator right now !
'''
sching_id = self.next_sching_id()
if self.sching_logto == 'file':
fname = 'ext/sching_decs/sching_'+sching_id+'.log'
logging.basicConfig(filename=fname,filemode='w',level=logging.DEBUG)
elif self.sching_logto == 'console':
logging.basicConfig(level=logging.DEBUG)
else:
logging.error('Unexpected sching_logto=%s', self.sching_logto)
return
#
logging.info('<<< sching_id=%s starts >>>', sching_id)
self.update_sid_res_dict()
sching_opter = SchingOptimizer(self.sessions_beingserved_dict,
self.actual_res_dict,
self.sid_res_dict )
sching_opter.solve()
self.alloc_dict = sching_opter.get_sching_result()
logging.info('alloc_dict=\n%s', pprint.pformat(self.alloc_dict))
#
"""
logging.info('saving sching_dec to figs...')
self.perf_plotter.save_sching_result(g_info_dict = self.alloc_dict['general'],
s_info_dict = self.alloc_dict['s-wise'],
res_info_dict = self.alloc_dict['res-wise'])
"""
#Convert sching decs to rules
for s_id in range(0,self.N):
s_allocinfo_dict = self.alloc_dict['s-wise'][s_id]
#
itwalkinfo_dict = s_allocinfo_dict['itwalkinfo_dict']
p_walk_dict = s_allocinfo_dict['pwalk_dict']
for p_id in range(0,s_allocinfo_dict['parism_level']):
p_walk = p_walk_dict[p_id]
sp_walk__tprrule = \
self.get_spwalkrule__sptprrule(s_id, p_id,
p_walk = p_walk,
pitwalkbundle_dict = itwalkinfo_dict[p_id])
logging.info('for s_id=%s, p_id=%s;', s_id, p_id)
#print 'walkrule:'
#pprint.pprint(sp_walk__tprrule['walk_rule'])
#print 'itjob_rule:'
#pprint.pprint(sp_walk__tprrule['itjob_rule'])
#
#Dispatching rule to actuator_actuator
msg = json.dumps({'type':'sp_sching_dec',
'data':{'s_id':s_id, 'p_id':p_id,
'walk_rule':sp_walk__tprrule['walk_rule'],
'itjob_rule':sp_walk__tprrule['itjob_rule']} })
self.cci.send_to_client('scher-acter', msg)
logging.info('<<< sching_id=%s ends >>>', sching_id)
def get_spwalkrule__sptprrule(self,s_id,p_id,p_walk,pitwalkbundle_dict):
def get_swportname(dpid, port):
return 's'+str(dpid)+'-eth'+str(port)
#print '---> for s_id:%i' % s_id
#print 'pitwalkbundle_dict:'
#pprint.pprint(pitwalkbundle_dict)
#print 'p_walk: ', p_walk
s_info_dict = self.sessions_beingserved_dict[s_id]
s_tp_dst = s_info_dict['tp_dst_list'][p_id]
p_c_ip_list = s_info_dict['p_c_ip_list']
#
itjob_rule_dict = {}
#
walk_rule = []
cur_from_ip = p_c_ip_list[0]
cur_to_ip = p_c_ip_list[1]
duration = 50
cur_node_str = None
for i,node_str in list(enumerate(p_walk)):#node = next_hop
if i == 0:
cur_node_str = node_str
#for adding reverse-walk rule for p_gw_sw
user_info_dict = self.users_beingserved_dict[cur_from_ip]
swportname = get_swportname(dpid = user_info_dict['gw_dpid'],
port = user_info_dict['gw_conn_port'])
node = self.gm.get_node(node_str)
walk_rule.append({'conn':[node['dpid'],cur_to_ip],
'typ':'forward',
'wc':[cur_to_ip,p_c_ip_list[0],int(s_tp_dst)],
'rule':[swportname, duration] })
#
continue
cur_node = self.gm.get_node(cur_node_str)
if cur_node['type'] == 't':
cur_node_str = node_str
continue
#
node = self.gm.get_node(node_str)
edge = self.gm.get_edge(cur_node_str, node_str)
if node['type'] == 't': #sw-t
walk_rule.append({'conn':[cur_node['dpid'],cur_from_ip],
'typ':'modify_forward',
'wc':[cur_from_ip,cur_to_ip,int(s_tp_dst)],
'rule':[node['ip'],node['mac'],edge['pre_dev'],duration]
})
if not (cur_node['dpid'] in itjob_rule_dict):
itjob_rule_dict[cur_node['dpid']] = [{
'tpr_ip':node['ip'],
'tpr_mac':node['mac'],
'swdev_to_tpr':edge['pre_dev'],
'assigned_job': pitwalkbundle_dict['itbundle'][node_str],
'session_tp': int(s_tp_dst),
'consumer_ip': cur_to_ip,
'datasize': pitwalkbundle_dict['p_info']['datasize'] }]
else:
itjob_rule_dict[cur_node['dpid']].append( [{
'tpr_ip':node['ip'],
'tpr_mac':node['mac'],
'swdev_to_tpr':edge['pre_dev'],
'assigned_job':pitwalkbundle_dict['itbundle'][node_str],
'session_tp': int(s_tp_dst),
'consumer_ip': cur_to_ip,
'datasize': pitwalkbundle_dict['p_info']['datasize'] }] )
cur_from_ip = node['ip']
elif node['type'] == 'sw': #sw-sw
walk_rule.append({'conn':[cur_node['dpid'],cur_from_ip],
'typ':'forward',
'wc':[cur_from_ip,cur_to_ip,int(s_tp_dst)],
'rule':[edge['pre_dev'], duration] })
cur_from_ip
#for reverse walk: data from c to p
walk_rule.append({'conn':[node['dpid'],cur_to_ip],
'typ':'forward',
'wc':[cur_to_ip,p_c_ip_list[0],int(s_tp_dst)],
'rule':[edge['post_dev'], duration] })
'''
#to deliver sch_response to src
walk_rule.append({'conn':[node['dpid'],info_dict['scher_vip']],
'typ':'forward',
'wc':[info_dict['scher_vip'],p_c_ip_list[0], info_dict['sching_port']],
'rule':[edge['post_dev'], duration] })
'''
else:
raise KeyError('Unknown node_type')
cur_node_str = node_str
#default rule to forward packet to consumer
user_info_dict = self.users_beingserved_dict[cur_to_ip]
swportname = get_swportname(dpid = user_info_dict['gw_dpid'],
port = user_info_dict['gw_conn_port'])
walk_rule.append({'conn':[user_info_dict['gw_dpid'],cur_from_ip],
'typ':'forward',
'wc':[cur_from_ip,cur_to_ip,int(s_tp_dst)],
'rule':[swportname,duration] })
"""
#default rule to forward sch_response to producer
walk_rule.append({'conn':[11,info_dict['scher_vip']],
'typ':'forward',
'wc':[info_dict['scher_vip'],p_c_ip_list[0]],
'rule':['s11-eth1',duration] })
"""
return {'walk_rule':walk_rule, 'itjob_rule':itjob_rule_dict}
##############################################################################
def test(self):
userinfo_list = [ {'user_ip':'10.0.0.2','user_mac':'00:00:00:01:00:02','gw_dpid':11,'gw_conn_port':1},
{'user_ip':'10.0.0.1','user_mac':'00:00:00:01:00:01','gw_dpid':12,'gw_conn_port':2} ]
for userinfo in userinfo_list:
self.welcome_user(user_ip = userinfo['user_ip'],
user_mac = userinfo['user_mac'],
gw_dpid = userinfo['gw_dpid'],
gw_conn_port = userinfo['gw_conn_port'] )
#
num_session = 1
req_dict_list = [ {'data_size':4, 'slack_metric':24, 'func_list':['f1','f2','f3'], 'parism_level':1, 'par_share':[1]},
{'data_size':1, 'slack_metric':24, 'func_list':['f1','f2','f3'], 'parism_level':2, 'par_share':[0.5, 0.5]},
{'data_size':1, 'slack_metric':24, 'func_list':['f1','f2','f3'], 'parism_level':2, 'par_share':[0.5, 0.5]},
{'data_size':1, 'slack_metric':24, 'func_list':['f1','f2','f3'], 'parism_level':2, 'par_share':[0.5, 0.5]},
{'data_size':1, 'slack_metric':24, 'func_list':['f1','f2','f3'], 'parism_level':2, 'par_share':[0.5, 0.5]},
{'data_size':1, 'slack_metric':24, 'func_list':['f1','f2','f3'], 'parism_level':2, 'par_share':[0.5, 0.5]},
{'data_size':1, 'slack_metric':24, 'func_list':['f1','f2','f3'], 'parism_level':2, 'par_share':[0.5, 0.5]},
{'data_size':1, 'slack_metric':24, 'func_list':['f1','f2','f3'], 'parism_level':2, 'par_share':[0.5, 0.5]},
{'data_size':1, 'slack_metric':24, 'func_list':['f1','f2','f3'], 'parism_level':2, 'par_share':[0.5, 0.5]},
{'data_size':1, 'slack_metric':24, 'func_list':['f1','f2','f3'], 'parism_level':2, 'par_share':[0.5, 0.5]},
]
app_pref_dict_list = [
{'m_p': 10,'m_u': 1,'x_p': 0,'x_u': 0},
{'m_p': 10,'m_u': 0.5,'x_p': 0,'x_u': 0},
{'m_p': 1,'m_u': 0.5,'x_p': 0,'x_u': 0},
{'m_p': 1,'m_u': 1,'x_p': 0,'x_u': 0},
{'m_p': 1,'m_u': 1,'x_p': 0,'x_u': 0},
{'m_p': 1,'m_u': 1,'x_p': 0,'x_u': 0},
{'m_p': 1,'m_u': 1,'x_p': 0,'x_u': 0},
{'m_p': 1,'m_u': 1,'x_p': 0,'x_u': 0},
{'m_p': 1,'m_u': 1,'x_p': 0,'x_u': 0},
{'m_p': 1,'m_u': 1,'x_p': 0,'x_u': 0},
]
p_c_ip_list_list = [
['10.0.0.2','10.0.0.1'],
]
for i in range(0, num_session):
self.welcome_session(p_c_ip_list = p_c_ip_list_list[0],
req_dict = req_dict_list[i],
app_pref_dict = app_pref_dict_list[i] )
self.do_sching()
class Scheduler(object):
#event_chief = EventChief()
def __init__(self, xml_network_number):
self.gm = GraphMan()
if is_scheduler_run:
self.xml_parser = XMLParser("net_xmls/net_2p_stwithsingleitr.xml",
str(xml_network_number))
else:
self.xml_parser = XMLParser(
"ext/net_xmls/net_2p_stwithsingleitr.xml",
str(xml_network_number))
self.init_network_from_xml()
#Useful state variables
self.last_sch_req_id_given = -1
self.last_tp_dst_given = info_dict['base_sport'] - 1
#Scher state dicts
self.N = 0 #num_activesessions
self.sessions_beingserved_dict = {}
self.sessions_pre_served_dict = {}
self.sid_res_dict = {}
self.actual_res_dict = self.gm.give_actual_resource_dict()
#for perf plotting
self.perf_plotter = PerfPlotter(self.actual_res_dict)
#for control_comm
self.cci = ControlCommIntf()
self.cci.reg_commpair(sctag='scher-acter',
proto='tcp',
_recv_callback=self._handle_recvfromacter,
s_addr=info_dict['lacter_addr'],
c_addr=info_dict['acterl_addr'])
def _handle_recvfromacter(self, msg):
#msg = [type_, data_]
print 'recvedfromacter msg=%s' % msg
def print_scher_state(self):
print '<-------------------H--------------------->'
print 'is_scheduler_run: ', is_scheduler_run
print 'sessions_beingserved_dict:'
pprint.pprint(self.sessions_beingserved_dict)
print 'sessions_pre_served_dict:'
pprint.pprint(self.sessions_pre_served_dict)
print '<-------------------E--------------------->'
def next_sch_req_id(self):
self.last_sch_req_id_given += 1
return self.last_sch_req_id_given
def next_tp_dst(self):
self.last_tp_dst_given += 1
return self.last_tp_dst_given
def welcome_session(self, p_c_ip_list, p_c_gw_list, req_dict,
app_pref_dict):
"""
sch_req_id: should be unique for every sch_session
"""
#update global var, list and dicts
self.N += 1
s_tp_dst_list = [
self.next_tp_dst() for i in range(0, req_dict['parism_level'])
]
sch_req_id = self.next_sch_req_id()
self.sessions_beingserved_dict.update({
sch_req_id: {
'tp_dst_list': s_tp_dst_list,
'req_dict': req_dict,
'p_c_ip_list': p_c_ip_list,
'p_c_gw_list': p_c_gw_list,
'app_pref_dict': app_pref_dict,
'sch_job_done': False
}
})
#print 'self.sessions_beingserved_dict: '
#pprint.pprint(self.sessions_beingserved_dict)
def bye_session(self, sch_req_id):
self.N -= 1
# Send sessions whose "sching job" is done is sent to pre_served category
self.sessions_pre_served_dict.update(
{sch_req_id: self.sessions_beingserved_dict[sch_req_id]})
del self.sessions_beingserved_dict[sch_req_id]
def update_sid_res_dict(self):
"""
Network resources will be only the ones on the session_shortest path.
It resources need to lie on the session_shortest path.
"""
print '------ update_sid_res_dict ------'
#TODO: sessions whose resources are already specified no need for putting them in the loop
for s_id in self.sessions_beingserved_dict:
p_c_gw_list = self.sessions_beingserved_dict[s_id]['p_c_gw_list']
s_all_paths = self.gm.give_all_paths(p_c_gw_list[0],
p_c_gw_list[1])
#print out all_paths for debugging
dict_ = {i: p for i, p in enumerate(s_all_paths)}
print 's_id:%i, all_paths:' % s_id
pprint.pprint(dict_)
#
for i, p in dict_.items():
p_net_edge_list = self.gm.pathlist_to_netedgelist(p)
p_itres_list = self.gm.give_itreslist_on_path(p)
if not (s_id in self.sid_res_dict):
self.sid_res_dict[s_id] = {'s_info': {}, 'ps_info': {}}
self.sid_res_dict[s_id]['ps_info'].update({
i: {
'path': p,
'net_edge_list': p_net_edge_list,
'itres_list': p_itres_list
}
})
print '---------------- OOO ----------------'
def do_sching(self):
'''
For currently active sessions, get things together to work sching logic and
then send corresponding rules to correspoding actuator (which is a single
actuator right now !)
'''
alloc_dict = self.allocate_resources()
print '---------------SCHING Started ---------------'
print 'alloc_dict:'
pprint.pprint(alloc_dict)
#'''
self.perf_plotter.save_sching_result(alloc_dict['general'],
alloc_dict['s-wise'],
alloc_dict['res-wise'])
#'''
#Convert sching decs to rules
print '**** self.N: ', self.N
for s_id in range(0, self.N):
s_allocinfo_dict = alloc_dict['s-wise'][s_id]
#
itwalkinfo_dict = s_allocinfo_dict['itwalkinfo_dict']
p_walk_dict = s_allocinfo_dict['pwalk_dict']
for p_id in range(0, s_allocinfo_dict['parism_level']):
p_walk = p_walk_dict[p_id]
#Dispatching rule to actuator_actuator
sp_walk__tprrule = \
self.get_spwalkrule__sptprrule(s_id, p_id,
p_walk = p_walk,
pitwalkbundle_dict = itwalkinfo_dict[p_id])
print 'for s_id:%i, p_id:%i;' % (s_id, p_id)
#print 'walkrule:'
#pprint.pprint(sp_walk__tprrule['walk_rule'])
#print 'itjob_rule:'
#pprint.pprint(sp_walk__tprrule['itjob_rule'])
msg = json.dumps({
'type': 'sp_sching_dec',
'data': {
's_id': s_id,
'p_id': p_id,
'walk_rule': sp_walk__tprrule['walk_rule'],
'itjob_rule': sp_walk__tprrule['itjob_rule']
}
})
self.cci.send_to_client('scher-acter', msg)
print '---------------SCHING End---------------'
def get_spwalkrule__sptprrule(self, s_id, p_id, p_walk,
pitwalkbundle_dict):
#print '---> for s_id:%i' % s_id
#print 'pitwalkbundle_dict:'
#pprint.pprint(pitwalkbundle_dict)
#print 'p_walk: ', p_walk
s_info_dict = self.sessions_beingserved_dict[s_id]
s_tp_dst = s_info_dict['tp_dst_list'][p_id]
p_c_ip_list = s_info_dict['p_c_ip_list']
#
itjob_rule_dict = {}
#
walk_rule = []
cur_from_ip = p_c_ip_list[0]
cur_to_ip = p_c_ip_list[1]
duration = 50
cur_node_str = None
for i, node_str in list(enumerate(p_walk)): #node = next_hop
if i == 0:
cur_node_str = node_str
#for adding reverse-walk rule for gw_sw
#TODO: 's11-eth1' must be gotten autonomously
node = self.gm.get_node(node_str)
walk_rule.append({
'conn': [node['dpid'], cur_to_ip],
'typ':
'forward',
'wc': [cur_to_ip, p_c_ip_list[0],
int(s_tp_dst)],
'rule': ['s11-eth1', duration]
})
#
continue
cur_node = self.gm.get_node(cur_node_str)
if cur_node['type'] == 't':
cur_node_str = node_str
continue
#
node = self.gm.get_node(node_str)
edge = self.gm.get_edge(cur_node_str, node_str)
if node['type'] == 't': #sw-t
walk_rule.append({
'conn': [cur_node['dpid'], cur_from_ip],
'typ':
'modify_forward',
'wc': [cur_from_ip, cur_to_ip,
int(s_tp_dst)],
'rule':
[node['ip'], node['mac'], edge['pre_dev'], duration]
})
if not (cur_node['dpid'] in itjob_rule_dict):
itjob_rule_dict[cur_node['dpid']] = [{
'tpr_ip':
node['ip'],
'tpr_mac':
node['mac'],
'swdev_to_tpr':
edge['pre_dev'],
'assigned_job':
pitwalkbundle_dict['itbundle'][node_str],
'session_tp':
int(s_tp_dst),
'consumer_ip':
cur_to_ip,
'datasize':
pitwalkbundle_dict['p_info']['datasize']
}]
else:
itjob_rule_dict[cur_node['dpid']].append([{
'tpr_ip':
node['ip'],
'tpr_mac':
node['mac'],
'swdev_to_tpr':
edge['pre_dev'],
'assigned_job':
pitwalkbundle_dict['itbundle'][node_str],
'session_tp':
int(s_tp_dst),
'consumer_ip':
cur_to_ip,
'datasize':
pitwalkbundle_dict['p_info']['datasize']
}])
cur_from_ip = node['ip']
elif node['type'] == 'sw': #sw-sw
walk_rule.append({
'conn': [cur_node['dpid'], cur_from_ip],
'typ': 'forward',
'wc': [cur_from_ip, cur_to_ip,
int(s_tp_dst)],
'rule': [edge['pre_dev'], duration]
})
cur_from_ip
#for reverse walk: data from c to p
walk_rule.append({
'conn': [node['dpid'], cur_to_ip],
'typ':
'forward',
'wc': [cur_to_ip, p_c_ip_list[0],
int(s_tp_dst)],
'rule': [edge['post_dev'], duration]
})
'''
#to deliver sch_response to src
walk_rule.append({'conn':[node['dpid'],info_dict['scher_vip']],
'typ':'forward',
'wc':[info_dict['scher_vip'],p_c_ip_list[0], info_dict['sching_tp_dst']],
'rule':[edge['post_dev'], duration] })
'''
else:
raise KeyError('Unknown node_type')
cur_node_str = node_str
#default rule to forward packet to consumer
#TODO: 's12-eth2' must be gotten autonomously
walk_rule.append({
'conn': [12, cur_from_ip],
'typ': 'forward',
'wc': [cur_from_ip, cur_to_ip,
int(s_tp_dst)],
'rule': ['s12-eth2', duration]
})
"""
#default rule to forward sch_response to producer
walk_rule.append({'conn':[11,info_dict['scher_vip']],
'typ':'forward',
'wc':[info_dict['scher_vip'],p_c_ip_list[0]],
'rule':['s11-eth1',duration]
})
"""
return {'walk_rule': walk_rule, 'itjob_rule': itjob_rule_dict}
def allocate_resources(self):
#returns alloc_dict
self.update_sid_res_dict()
sching_opter = SchingOptimizer(self.sessions_beingserved_dict,
self.actual_res_dict, self.sid_res_dict)
sching_opter.solve()
#
return sching_opter.get_sching_result()
def init_network_from_xml(self):
node_edge_lst = self.xml_parser.give_node_and_edge_list_from_xml()
#print 'node_lst:'
#pprint.pprint(node_edge_lst['node_lst'])
#print 'edge_lst:'
#pprint.pprint(node_edge_lst['edge_lst'])
self.gm.graph_add_nodes(node_edge_lst['node_lst'])
self.gm.graph_add_edges(node_edge_lst['edge_lst'])
def test(self):
num_session = 2
'''
sr1:
{'data_size':1, 'slack_metric':24, 'func_list':['f1','f2','f3']}
{'m_p': 1,'m_u': 1,'x_p': 0,'x_u': 0}
'''
'''
{'data_size':2, 'slack_metric':60, 'func_list':['f1', 'f2']},
{'data_size':1, 'slack_metric':24, 'func_list':['f1','f2','f3']},
{'data_size':0.1, 'slack_metric':4, 'func_list':['f1']},
'''
req_dict_list = [
{
'data_size': 1,
'slack_metric': 24,
'func_list': ['f1', 'f2', 'f3'],
'parism_level': 1,
'par_share': [1]
},
{
'data_size': 1,
'slack_metric': 24,
'func_list': ['f1', 'f2', 'f3'],
'parism_level': 2,
'par_share': [0.5, 0.5]
},
{
'data_size': 1,
'slack_metric': 24,
'func_list': ['f1', 'f2', 'f3'],
'parism_level': 2,
'par_share': [0.5, 0.5]
},
{
'data_size': 1,
'slack_metric': 24,
'func_list': ['f1', 'f2', 'f3'],
'parism_level': 2,
'par_share': [0.5, 0.5]
},
{
'data_size': 1,
'slack_metric': 24,
'func_list': ['f1', 'f2', 'f3'],
'parism_level': 2,
'par_share': [0.5, 0.5]
},
{
'data_size': 1,
'slack_metric': 24,
'func_list': ['f1', 'f2', 'f3'],
'parism_level': 2,
'par_share': [0.5, 0.5]
},
{
'data_size': 1,
'slack_metric': 24,
'func_list': ['f1', 'f2', 'f3'],
'parism_level': 2,
'par_share': [0.5, 0.5]
},
{
'data_size': 1,
'slack_metric': 24,
'func_list': ['f1', 'f2', 'f3'],
'parism_level': 2,
'par_share': [0.5, 0.5]
},
{
'data_size': 1,
'slack_metric': 24,
'func_list': ['f1', 'f2', 'f3'],
'parism_level': 2,
'par_share': [0.5, 0.5]
},
{
'data_size': 1,
'slack_metric': 24,
'func_list': ['f1', 'f2', 'f3'],
'parism_level': 2,
'par_share': [0.5, 0.5]
},
]
"""
app_pref_dict_list = [
{'m_p': 1,'m_u': 0.1,'x_p': 0,'x_u': 0},
{'m_p': 1,'m_u': 1,'x_p': 0,'x_u': 0},
{'m_p': 1,'m_u': 1,'x_p': 0,'x_u': 0},
{'m_p': 1,'m_u': 1,'x_p': 0,'x_u': 0},
{'m_p': 1,'m_u': 1,'x_p': 0,'x_u': 0},
{'m_p': 1,'m_u': 1,'x_p': 0,'x_u': 0},
{'m_p': 1,'m_u': 1,'x_p': 0,'x_u': 0},
{'m_p': 1,'m_u': 1,'x_p': 0,'x_u': 0},
{'m_p': 1,'m_u': 1,'x_p': 0,'x_u': 0},
{'m_p': 1,'m_u': 1,'x_p': 0,'x_u': 0},
]
"""
app_pref_dict_list = [
{
'm_p': 10,
'm_u': 1,
'x_p': 0,
'x_u': 0
},
{
'm_p': 10,
'm_u': 0.5,
'x_p': 0,
'x_u': 0
},
{
'm_p': 1,
'm_u': 0.5,
'x_p': 0,
'x_u': 0
},
{
'm_p': 1,
'm_u': 1,
'x_p': 0,
'x_u': 0
},
{
'm_p': 1,
'm_u': 1,
'x_p': 0,
'x_u': 0
},
{
'm_p': 1,
'm_u': 1,
'x_p': 0,
'x_u': 0
},
{
'm_p': 1,
'm_u': 1,
'x_p': 0,
'x_u': 0
},
{
'm_p': 1,
'm_u': 1,
'x_p': 0,
'x_u': 0
},
{
'm_p': 1,
'm_u': 1,
'x_p': 0,
'x_u': 0
},
{
'm_p': 1,
'm_u': 1,
'x_p': 0,
'x_u': 0
},
]
p_c_ip_list_list = [
['10.0.0.2', '10.0.0.1'],
]
p_c_gw_list_list = [
['s11', 's12'],
]
for i in range(0, num_session):
self.welcome_session(p_c_ip_list_list[0], p_c_gw_list_list[0],
req_dict_list[i], app_pref_dict_list[i])
self.do_sching()
"""
