def __init__( self, session: "Session", _id: int = None, name: str = None, server: "DistributedServer" = None, ) -> None: """ Creates a NodeBase instance. :param session: CORE session object :param _id: id :param name: object name :param server: remote server node will run on, default is None for localhost """ self.session: "Session" = session if _id is None: _id = session.next_node_id() self.id: int = _id if name is None: name = f"o{self.id}" self.name: str = name self.server: "DistributedServer" = server self.type: Optional[str] = None self.services: CoreServices = [] self.ifaces: Dict[int, CoreInterface] = {} self.iface_id: int = 0 self.canvas: Optional[int] = None self.icon: Optional[str] = None self.position: Position = Position() self.up: bool = False self.net_client: LinuxNetClient = get_net_client( self.session.use_ovs(), self.host_cmd)
def __init__(self, session, node, name, mtu, server=None): """ Creates a CoreInterface instance. :param core.emulator.session.Session session: core session instance :param core.nodes.base.CoreNode node: node for interface :param str name: interface name :param int mtu: mtu value :param core.emulator.distributed.DistributedServer server: remote server node will run on, default is None for localhost """ self.session = session self.node = node self.name = name if not isinstance(mtu, int): raise ValueError self.mtu = mtu self.net = None self._params = {} self.addrlist = [] self.hwaddr = None # placeholder position hook self.poshook = lambda a, b, c, d: None # used with EMANE self.transport_type = None # node interface index self.netindex = None # net interface index self.netifi = None # index used to find flow data self.flow_id = None self.server = server use_ovs = session.options.get_config("ovs") == "True" self.net_client = get_net_client(use_ovs, self.host_cmd)
def __init__(self, session, _id=None, name=None, start=True, server=None): """ Creates a PyCoreObj instance. :param core.emulator.session.Session session: CORE session object :param int _id: id :param str name: object name :param bool start: start value :param core.emulator.distributed.DistributedServer server: remote server node will run on, default is None for localhost """ self.session = session if _id is None: _id = session.get_node_id() self.id = _id if name is None: name = f"o{self.id}" self.name = name self.server = server self.type = None self.services = None # ifindex is key, CoreInterface instance is value self._netif = {} self.ifindex = 0 self.canvas = None self.icon = None self.opaque = None self.position = Position() use_ovs = session.options.get_config("ovs") == "True" self.net_client = get_net_client(use_ovs, self.host_cmd)
def create_node_net_client(self, use_ovs: bool) -> LinuxNetClient: """ Create node network client for running network commands within the nodes container. :param use_ovs: True for OVS bridges, False for Linux bridges :return:node network client """ return get_net_client(use_ovs, self.nsenter_cmd)
def add_addresses(self, address): """ Add addresses used for created control networks, :param core.nodes.interfaces.IpAddress address: starting address to use :return: """ use_ovs = self.session.options.get_config("ovs") == "True" current = f"{address}/{self.prefix.prefixlen}" net_client = get_net_client(use_ovs, utils.cmd) net_client.create_address(self.brname, current) servers = self.session.distributed.servers for name in servers: server = servers[name] address -= 1 current = f"{address}/{self.prefix.prefixlen}" net_client = get_net_client(use_ovs, server.remote_cmd) net_client.create_address(self.brname, current)
def __init__( self, session: "Session", name: str, localname: str, mtu: int = DEFAULT_MTU, server: "DistributedServer" = None, node: "CoreNode" = None, ) -> None: """ Creates a CoreInterface instance. :param session: core session instance :param name: interface name :param localname: interface local name :param mtu: mtu value :param server: remote server node will run on, default is None for localhost :param node: node for interface """ if len(name) >= 16: raise CoreError(f"interface name ({name}) too long, max 16") if len(localname) >= 16: raise CoreError( f"interface local name ({localname}) too long, max 16") self.session: "Session" = session self.node: Optional["CoreNode"] = node self.name: str = name self.localname: str = localname self.up: bool = False self.mtu: int = mtu self.net: Optional[CoreNetworkBase] = None self.othernet: Optional[CoreNetworkBase] = None self.ip4s: List[netaddr.IPNetwork] = [] self.ip6s: List[netaddr.IPNetwork] = [] self.mac: Optional[netaddr.EUI] = None # placeholder position hook self.poshook: Callable[[CoreInterface], None] = lambda x: None # used with EMANE self.transport_type: TransportType = TransportType.VIRTUAL # id of interface for node self.node_id: Optional[int] = None # id of interface for network self.net_id: Optional[int] = None # id used to find flow data self.flow_id: Optional[int] = None self.server: Optional["DistributedServer"] = server self.net_client: LinuxNetClient = get_net_client( self.session.use_ovs(), self.host_cmd) self.control: bool = False # configuration data self.has_local_netem: bool = False self.local_options: LinkOptions = LinkOptions() self.has_netem: bool = False self.options: LinkOptions = LinkOptions()
def add_addresses(self, index: int) -> None: """ Add addresses used for created control networks, :param index: starting address index :return: nothing """ use_ovs = self.session.use_ovs() address = self.prefix[index] current = f"{address}/{self.prefix.prefixlen}" net_client = get_net_client(use_ovs, utils.cmd) net_client.create_address(self.brname, current) servers = self.session.distributed.servers for name in servers: server = servers[name] index -= 1 address = self.prefix[index] current = f"{address}/{self.prefix.prefixlen}" net_client = get_net_client(use_ovs, server.remote_cmd) net_client.create_address(self.brname, current)
def __init__( self, session: "Session", node: "CoreNode", name: str, localname: str, mtu: int, server: "DistributedServer" = None, ) -> None: """ Creates a CoreInterface instance. :param session: core session instance :param node: node for interface :param name: interface name :param localname: interface local name :param mtu: mtu value :param server: remote server node will run on, default is None for localhost """ self.session: "Session" = session self.node: "CoreNode" = node self.name: str = name self.localname: str = localname self.up: bool = False self.mtu: int = mtu self.net: Optional[CoreNetworkBase] = None self.othernet: Optional[CoreNetworkBase] = None self._params: Dict[str, float] = {} self.ip4s: List[netaddr.IPNetwork] = [] self.ip6s: List[netaddr.IPNetwork] = [] self.mac: Optional[netaddr.EUI] = None # placeholder position hook self.poshook: Callable[[CoreInterface], None] = lambda x: None # used with EMANE self.transport_type: TransportType = TransportType.VIRTUAL # id of interface for node self.node_id: Optional[int] = None # id of interface for network self.net_id: Optional[int] = None # id used to find flow data self.flow_id: Optional[int] = None self.server: Optional["DistributedServer"] = server self.net_client: LinuxNetClient = get_net_client( self.session.use_ovs(), self.host_cmd) self.control: bool = False
def __init__( self, session: "Session", node: "CoreNode", name: str, localname: str, mtu: int, server: "DistributedServer" = None, ) -> None: """ Creates a CoreInterface instance. :param session: core session instance :param node: node for interface :param name: interface name :param localname: interface local name :param mtu: mtu value :param server: remote server node will run on, default is None for localhost """ self.session: "Session" = session self.node: "CoreNode" = node self.name: str = name self.localname: str = localname self.up: bool = False self.mtu: int = mtu self.net: Optional[CoreNetworkBase] = None self.othernet: Optional[CoreNetworkBase] = None self._params: Dict[str, float] = {} self.addrlist: List[str] = [] self.hwaddr: Optional[str] = None # placeholder position hook self.poshook: Callable[[CoreInterface], None] = lambda x: None # used with EMANE self.transport_type: Optional[TransportType] = None # node interface index self.netindex: Optional[int] = None # net interface index self.netifi: Optional[int] = None # index used to find flow data self.flow_id: Optional[int] = None self.server: Optional["DistributedServer"] = server use_ovs = session.options.get_config("ovs") == "True" self.net_client: LinuxNetClient = get_net_client(use_ovs, self.host_cmd)