def add_entity(self, entity_type, *properties): entity_class = LogicalEntityZoo.logical_entity_types.get(entity_type) if entity_class is None: logger.warning('unknow entity_type %s', entity_type) return entity_id = properties[0] entity_group = self.entity_set[entity_type] with self.lock: if entity_group.has_key(entity_id) and \ entity_group[entity_id].is_same(*properties): logger.info( 'entity_set[%s] has same property entity ' 'exist entity:%s, conflict entity:%s', entity_type, entity_group[entity_id], properties) return try: e = entity_class(*properties) except Exception as err: logger.exception( "hit error in adding entity %s, " "property:%s, err:%s", entity_type, properties, err) return self._add_entity_in_zoo(entity_type, e) # a chassis which a LR pin on should be touch to generate # tunnel. This tunnel was use to redirect traffic. if not get_extra()['options'].has_key('ONDEMAND'): return # a LR pin on a remote chassis means this chassis s a # gateway or agent. The tunnel should be generated immediately. if entity_type == LOGICAL_ENTITY_TYPE_LR: self._touch_gateway_by_LR(e) if entity_type == LOGICAL_ENTITY_TYPE_CHASSIS: self._touch_gateway_by_chassis(e)
def process_trace(trace_msg_seg): table_id = trace_msg_seg[1] datapath_id = trace_msg_seg[2] cmd_id = int(trace_msg_seg[3]) >> 16 src_port_id = trace_msg_seg[4] dst_port_id = trace_msg_seg[5] tun_src = int(trace_msg_seg[6]) seq_n = trace_msg_seg[7] logger.info( 'tracing packets, table_id:%s, datapath_id:%s, ' 'cmd_id:%d, src_port_id:%s, dst_port_id:%s, seq:%s, tun_src:%d', table_id, datapath_id, cmd_id, src_port_id, dst_port_id, seq_n, tun_src) ttl = 30 chassis_id = get_extra()['system_id'] key = "cmd_result/{}/{}/{}".format(cmd_id, seq_n, chassis_id) value = "cmd_type=pkt_trace,table_id={},datapath_id={},src_port_id={},dst_port_id={},tun_src={}".format( table_id, datapath_id, src_port_id, dst_port_id, tun_src) wmaster = extra['lm'] wmaster.lease_communicate(key, value, ttl)
def init_entity_clause(options): local_bond_lsp(LSP_WITH_OFPORT, LS, State) <= ( ovsport(PORT_NAME, UUID_LSP, OFPORT, State1) & (OFPORT > 0) & ls_array(LS, UUID_LS, State2) & lsp_array(UUID_LSP, LSP, UUID_LS, UUID_CHASSIS, UUID_LRP, State3) & local_system_id(UUID_CHASSIS) & (LSP_WITH_OFPORT == (LSP + [OFPORT])) & (State == State1 + State2 + State3)) local_lsp(LSP, LS, State) <= ((UUID_LR_CHASSIS == None) & lsp_link_lrp( LSP, LS, UUID_LS, LRP, LR, UUID_LR, UUID_LR_CHASSIS, State)) local_lsp(LSP, LS, State) <= (local_system_id(UUID_LR_CHASSIS) & lsp_link_lrp( LSP, LS, UUID_LS, LRP, LR, UUID_LR, UUID_LR_CHASSIS, State)) local_lsp(LSP, LS, State) <= (local_bond_lsp(LSP, LS, State)) active_lsp(LSP, LS, UUID_LS, State) <= (ls_array(LS, UUID_LS, State1) & lsp_array( UUID_LSP, LSP, UUID_LS, UUID_CHASSIS, UUID_LRP, State2) & chassis_array(PHY_CHASSIS, UUID_CHASSIS, State3) & (State == State1 + State2 + State3)) active_lsp(LSP, LS, UUID_LS, State) <= (lsp_link_lrp( LSP, LS, UUID_LS, LRP, LR, UUID_LR, UUID_LR_CHASSIS, State)) remote_chassis(UUID_CHASSIS, PHY_CHASSIS_WITH_OFPORT, State) <= ( ovsport_chassis(PORT_NAME, UUID_CHASSIS, OFPORT, State1) & (OFPORT > 0) & chassis_array(PHY_CHASSIS, UUID_CHASSIS, State2) & (PHY_CHASSIS_WITH_OFPORT == PHY_CHASSIS + [OFPORT]) & (State == State1 + State2)) local_chassis(PHY_CHASSIS, State) <= (local_system_id(UUID_CHASSIS) & chassis_array(PHY_CHASSIS, UUID_CHASSIS, State)) remote_lsp(LSP, LS, PHY_CHASSIS, State) <= ( remote_chassis(UUID_CHASSIS, PHY_CHASSIS, State1) & lsp_array(UUID_LSP, LSP, UUID_LS, UUID_CHASSIS, UUID_LRP, State2) & ls_array(LS, UUID_LS, State3) & (State == State1 + State2 + State3)) remote_lsp(LSP, LS, PHY_CHASSIS, State) <= (lsp_link_lrp( LSP, LS, UUID_LS, LRP, LR, UUID_LR, UUID_LR_CHASSIS, State1) & remote_chassis(UUID_LR_CHASSIS, PHY_CHASSIS, State2) & (State == State1 + State2)) lsp_link_lrp( LSP, LS, UUID_LS, LRP, LR, UUID_LR, UUID_LR_CHASSIS, State) <= ( lrp_array(UUID_LRP, LRP, UUID_LR, UUID_LSP, State1) & exchange_lsp_array(UUID_LSP, LSP, UUID_LS, UUID_CHASSIS, UUID_LRP, State2) & ls_array(LS, UUID_LS, State3) & lr_array(LR, UUID_LR, State4) & (UUID_LR_CHASSIS == LR[LR_CHASSIS_UUID]) & (State == State1 + State2 + State3 + State4)) next_hop_ovsport(UUID_LRP, OFPORT, State) <= ( lrp_array(UUID_LRP, LRP, UUID_LR, UUID_LSP, State1) & exchange_lsp_array(UUID_LSP1, LSP1, UUID_LS, UUID_CHASSIS1, UUID_LRP, State2) & exchange_lsp_array(UUID_LSP2, LSP2, UUID_LS, UUID_CHASSIS2, UUID_LRP2, State3) & lrp_array(UUID_LRP2, LRP2, UUID_LR2, UUID_LSP2, State4) & (UUID_LR != UUID_LR2) & lr_array(LR2, UUID_LR2, State5) & ovsport_chassis(PORT_NAME, LR2[LR_CHASSIS_UUID], OFPORT, State6) & (State == State1 + State2 + State3 + State4 + State5 + State6)) if not get_extra()['options'].has_key('ENABLE_PERFORMANCE_TESTING'): lnat_data(LNAT, LR, XLATE_TYPE, UUID_LR, State) <= ( lr_array(LR, UUID_LR, State1) & # TODO local_system_id, UUID_CHASSIS here introduce # performance regression (UUID_CHASSIS == LR[LR_CHASSIS_UUID]) & local_system_id(UUID_CHASSIS) & lnat_array(LNAT, UUID_LR, XLATE_TYPE, State2) & (State == State1 + State2)) else: lnat_data(LNAT, LR, XLATE_TYPE, UUID_LR, State) <= (lr_array(LR, UUID_LR, State1) & lnat_array(LNAT, UUID_LR, XLATE_TYPE, State2) & (State == State1 + State2))
def _is_update_clause(self): if not get_extra()['options'].has_key('ONDEMAND'): return True if self.uuid == get_extra()['system_id']: return True return self.touched
import logging import subprocess import struct, socket import flow_common import run_env from pyDatalog import pyDatalog from commit_ovs import commit_flows from onexit import on_parent_exit from tp_utils import pipe from run_env import get_extra from tuplesync import update_ovs_side from logicalview import LOGICAL_ENTITY_TYPE_LSP, LOGICAL_ENTITY_TYPE_CHASSIS MAX_BUF_LEN = 10240 extra = run_env.get_extra() logger = logging.getLogger(__name__) entity_zoo = None def int_to_ip(ip_int): return socket.inet_ntoa(struct.pack('I', socket.htonl(ip_int))) def update_ovs_arp_ip_mac(mac_addr, ip_int): match = 'table={t},priority=1,ip,reg2={dst},'.format( t=flow_common.TABLE_SEARCH_IP_MAC, dst=ip_int) action = 'actions=mod_dl_dst:{}'.format(mac_addr) flow = match + action commit_flows([flow], [])
import pickle import socket import os import logging import threading import run_env options = run_env.get_extra()['options'] RUNNING_ENV_PATH = options['TUPLENET_RUNDIR'] PKT_CONTROLLER_PIPE_PATH = os.path.join(RUNNING_ENV_PATH, 'pkt_controller_pipe') DEBUG_PIPE_PATH = os.path.join(RUNNING_ENV_PATH, 'debug_pipe.sock') logger = logging.getLogger(__name__) logger.info('RUNNING_ENV_PATH:%s', RUNNING_ENV_PATH) plock = threading.Lock() def write_pipe(obj, path): with open(path, 'wb') as fd: pickle.dump(obj, fd) def write_pipe_cb(cb, path): with open(path, 'wb') as fd: obj = cb() pickle.dump(obj, fd) def read_pipe(path):
ch = PhysicalChassis( chassis_id, "192.{}.{}.{}".format(random.randint(1, 254), random.randint(1, 254), random.randint(1, 254)), int(time.time())) chassis_set[chassis_id] = ch start_time = time.time() tunnel.tunnel_port_oper(A, B, C) tmp = A.data tmp = B.data tmp = C.data logger.info('tunnel_port_oper cost time:%s, num:%d', time.time() - start_time, len(tmp)) start_time = time.time() active_lsp(A, B, C, State) tmp = A.data logger.info('active_lsp cost time:%s', time.time() - start_time) logger.info('\n\n') extra = get_extra() extra['system_id'] = 'chassis-local' extra['options'] = {} extra['options']['ENABLE_REDIRECT'] = '' extra['options']['ENABLE_PERFORMANCE_TESTING'] = '' extra['options']['ONDEMAND'] = '' entity_set = entity_zoo.entity_set lflow.init_build_flows_clause(extra['options']) test_rand_entity(entity_set, 200, 500, 5000)