afonso/core-extra
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity

updates to python based logging to use module named loggers, updated logging config file to align with these changes

Browse source
This commit is contained in:
Blake Harnden 2021-04-21 21:09:35 -07:00
parent 55d5bb3859
commit 69652ac577
63 changed files with 717 additions and 606 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

6
daemon/core/api/grpc/client.py
View file

@ -94,6 +94,8 @@ from core.api.grpc.wlan_pb2 import (
) )
from core.emulator.data import IpPrefixes from core.emulator.data import IpPrefixes
logger = logging.getLogger(__name__)
class InterfaceHelper: class InterfaceHelper:
""" """
@ -147,9 +149,9 @@ def stream_listener(stream: Any, handler: Callable[[core_pb2.Event], None]) -> N
handler(event) handler(event)
except grpc.RpcError as e: except grpc.RpcError as e:
if e.code() == grpc.StatusCode.CANCELLED: if e.code() == grpc.StatusCode.CANCELLED:
logging.debug("stream closed") logger.debug("stream closed")
else: else:
logging.exception("stream error") logger.exception("stream error")
def start_streamer(stream: Any, handler: Callable[[core_pb2.Event], None]) -> None: def start_streamer(stream: Any, handler: Callable[[core_pb2.Event], None]) -> None:

14
daemon/core/api/grpc/clientw.py
View file

@ -70,6 +70,8 @@ from core.api.grpc.wrappers import Hook
from core.emulator.data import IpPrefixes from core.emulator.data import IpPrefixes
from core.errors import CoreError from core.errors import CoreError
logger = logging.getLogger(__name__)
class MoveNodesStreamer: class MoveNodesStreamer:
def __init__(self, session_id: int = None, source: str = None) -> None: def __init__(self, session_id: int = None, source: str = None) -> None:
@ -184,9 +186,9 @@ def throughput_listener(
handler(event) handler(event)
except grpc.RpcError as e: except grpc.RpcError as e:
if e.code() == grpc.StatusCode.CANCELLED: if e.code() == grpc.StatusCode.CANCELLED:
logging.debug("throughput stream closed") logger.debug("throughput stream closed")
else: else:
logging.exception("throughput stream error") logger.exception("throughput stream error")
def cpu_listener( def cpu_listener(
@ -205,9 +207,9 @@ def cpu_listener(
handler(event) handler(event)
except grpc.RpcError as e: except grpc.RpcError as e:
if e.code() == grpc.StatusCode.CANCELLED: if e.code() == grpc.StatusCode.CANCELLED:
logging.debug("cpu stream closed") logger.debug("cpu stream closed")
else: else:
logging.exception("cpu stream error") logger.exception("cpu stream error")
def event_listener(stream: Any, handler: Callable[[wrappers.Event], None]) -> None: def event_listener(stream: Any, handler: Callable[[wrappers.Event], None]) -> None:
@ -224,9 +226,9 @@ def event_listener(stream: Any, handler: Callable[[wrappers.Event], None]) -> No
handler(event) handler(event)
except grpc.RpcError as e: except grpc.RpcError as e:
if e.code() == grpc.StatusCode.CANCELLED: if e.code() == grpc.StatusCode.CANCELLED:
logging.debug("session stream closed") logger.debug("session stream closed")
else: else:
logging.exception("session stream error") logger.exception("session stream error")
class CoreGrpcClient: class CoreGrpcClient:

4
daemon/core/api/grpc/events.py
View file

@ -14,6 +14,8 @@ from core.emulator.data import (
) )
from core.emulator.session import Session from core.emulator.session import Session
logger = logging.getLogger(__name__)
def handle_node_event(node_data: NodeData) -> core_pb2.Event: def handle_node_event(node_data: NodeData) -> core_pb2.Event:
""" """
@ -199,7 +201,7 @@ class EventStreamer:
elif isinstance(data, FileData): elif isinstance(data, FileData):
event = handle_file_event(data) event = handle_file_event(data)
else: else:
logging.error("unknown event: %s", data) logger.error("unknown event: %s", data)
except Empty: except Empty:
pass pass
if event: if event:

7
daemon/core/api/grpc/grpcutils.py
View file

@ -31,6 +31,7 @@ from core.nodes.lxd import LxcNode
from core.nodes.network import WlanNode from core.nodes.network import WlanNode
from core.services.coreservices import CoreService from core.services.coreservices import CoreService
logger = logging.getLogger(__name__)
WORKERS = 10 WORKERS = 10
@ -156,7 +157,7 @@ def create_nodes(
start = time.monotonic() start = time.monotonic()
results, exceptions = utils.threadpool(funcs) results, exceptions = utils.threadpool(funcs)
total = time.monotonic() - start total = time.monotonic() - start
logging.debug("grpc created nodes time: %s", total) logger.debug("grpc created nodes time: %s", total)
return results, exceptions return results, exceptions
@ -180,7 +181,7 @@ def create_links(
start = time.monotonic() start = time.monotonic()
results, exceptions = utils.threadpool(funcs) results, exceptions = utils.threadpool(funcs)
total = time.monotonic() - start total = time.monotonic() - start
logging.debug("grpc created links time: %s", total) logger.debug("grpc created links time: %s", total)
return results, exceptions return results, exceptions
@ -204,7 +205,7 @@ def edit_links(
start = time.monotonic() start = time.monotonic()
results, exceptions = utils.threadpool(funcs) results, exceptions = utils.threadpool(funcs)
total = time.monotonic() - start total = time.monotonic() - start
logging.debug("grpc edit links time: %s", total) logger.debug("grpc edit links time: %s", total)
return results, exceptions return results, exceptions

113
daemon/core/api/grpc/server.py
View file

@ -116,6 +116,7 @@ from core.nodes.base import CoreNode, NodeBase
from core.nodes.network import CtrlNet, PtpNet, WlanNode from core.nodes.network import CtrlNet, PtpNet, WlanNode
from core.services.coreservices import ServiceManager from core.services.coreservices import ServiceManager
logger = logging.getLogger(__name__)
_ONE_DAY_IN_SECONDS: int = 60 * 60 * 24 _ONE_DAY_IN_SECONDS: int = 60 * 60 * 24
_INTERFACE_REGEX: Pattern = re.compile(r"veth(?P<node>[0-9a-fA-F]+)") _INTERFACE_REGEX: Pattern = re.compile(r"veth(?P<node>[0-9a-fA-F]+)")
_MAX_WORKERS = 1000 _MAX_WORKERS = 1000
@ -136,7 +137,7 @@ class CoreGrpcServer(core_pb2_grpc.CoreApiServicer):
atexit.register(self._exit_handler) atexit.register(self._exit_handler)
def _exit_handler(self) -> None: def _exit_handler(self) -> None:
logging.debug("catching exit, stop running") logger.debug("catching exit, stop running")
self.running = False self.running = False
def _is_running(self, context) -> bool: def _is_running(self, context) -> bool:
@ -146,7 +147,7 @@ class CoreGrpcServer(core_pb2_grpc.CoreApiServicer):
context.abort(grpc.StatusCode.CANCELLED, "server stopping") context.abort(grpc.StatusCode.CANCELLED, "server stopping")
def listen(self, address: str) -> None: def listen(self, address: str) -> None:
logging.info("CORE gRPC API listening on: %s", address) logger.info("CORE gRPC API listening on: %s", address)
self.server = grpc.server(futures.ThreadPoolExecutor(max_workers=_MAX_WORKERS)) self.server = grpc.server(futures.ThreadPoolExecutor(max_workers=_MAX_WORKERS))
core_pb2_grpc.add_CoreApiServicer_to_server(self, self.server) core_pb2_grpc.add_CoreApiServicer_to_server(self, self.server)
self.server.add_insecure_port(address) self.server.add_insecure_port(address)
@ -217,7 +218,7 @@ class CoreGrpcServer(core_pb2_grpc.CoreApiServicer):
:param context: grpc context :param context: grpc context
:return: start session response :return: start session response
""" """
logging.debug("start session: %s", request) logger.debug("start session: %s", request)
session = self.get_session(request.session_id, context) session = self.get_session(request.session_id, context)
# clear previous state and setup for creation # clear previous state and setup for creation
@ -313,7 +314,7 @@ class CoreGrpcServer(core_pb2_grpc.CoreApiServicer):
:param context: grpc context :param context: grpc context
:return: stop session response :return: stop session response
""" """
logging.debug("stop session: %s", request) logger.debug("stop session: %s", request)
session = self.get_session(request.session_id, context) session = self.get_session(request.session_id, context)
session.data_collect() session.data_collect()
session.shutdown() session.shutdown()
@ -329,7 +330,7 @@ class CoreGrpcServer(core_pb2_grpc.CoreApiServicer):
:param context: :param context:
:return: a create-session response :return: a create-session response
""" """
logging.debug("create session: %s", request) logger.debug("create session: %s", request)
session = self.coreemu.create_session(request.session_id) session = self.coreemu.create_session(request.session_id)
session.set_state(EventTypes.DEFINITION_STATE) session.set_state(EventTypes.DEFINITION_STATE)
session.location.setrefgeo(47.57917, -122.13232, 2.0) session.location.setrefgeo(47.57917, -122.13232, 2.0)
@ -348,7 +349,7 @@ class CoreGrpcServer(core_pb2_grpc.CoreApiServicer):
:param context: context object :param context: context object
:return: a delete-session response :return: a delete-session response
""" """
logging.debug("delete session: %s", request) logger.debug("delete session: %s", request)
result = self.coreemu.delete_session(request.session_id) result = self.coreemu.delete_session(request.session_id)
return core_pb2.DeleteSessionResponse(result=result) return core_pb2.DeleteSessionResponse(result=result)
@ -362,7 +363,7 @@ class CoreGrpcServer(core_pb2_grpc.CoreApiServicer):
:param context: context object :param context: context object
:return: a delete-session response :return: a delete-session response
""" """
logging.debug("get sessions: %s", request) logger.debug("get sessions: %s", request)
sessions = [] sessions = []
for session_id in self.coreemu.sessions: for session_id in self.coreemu.sessions:
session = self.coreemu.sessions[session_id] session = self.coreemu.sessions[session_id]
@ -387,7 +388,7 @@ class CoreGrpcServer(core_pb2_grpc.CoreApiServicer):
:param context: context object :param context: context object
:return: a get-session-location response :return: a get-session-location response
""" """
logging.debug("get session location: %s", request) logger.debug("get session location: %s", request)
session = self.get_session(request.session_id, context) session = self.get_session(request.session_id, context)
x, y, z = session.location.refxyz x, y, z = session.location.refxyz
lat, lon, alt = session.location.refgeo lat, lon, alt = session.location.refgeo
@ -407,7 +408,7 @@ class CoreGrpcServer(core_pb2_grpc.CoreApiServicer):
:param context: context object :param context: context object
:return: a set-session-location-response :return: a set-session-location-response
""" """
logging.debug("set session location: %s", request) logger.debug("set session location: %s", request)
session = self.get_session(request.session_id, context) session = self.get_session(request.session_id, context)
grpcutils.session_location(session, request.location) grpcutils.session_location(session, request.location)
return core_pb2.SetSessionLocationResponse(result=True) return core_pb2.SetSessionLocationResponse(result=True)
@ -422,7 +423,7 @@ class CoreGrpcServer(core_pb2_grpc.CoreApiServicer):
:param context:context object :param context:context object
:return: set-session-state response :return: set-session-state response
""" """
logging.debug("set session state: %s", request) logger.debug("set session state: %s", request)
session = self.get_session(request.session_id, context) session = self.get_session(request.session_id, context)
try: try:
state = EventTypes(request.state) state = EventTypes(request.state)
@ -451,7 +452,7 @@ class CoreGrpcServer(core_pb2_grpc.CoreApiServicer):
:param context: context object :param context: context object
:return: set session user response :return: set session user response
""" """
logging.debug("set session user: %s", request) logger.debug("set session user: %s", request)
session = self.get_session(request.session_id, context) session = self.get_session(request.session_id, context)
session.user = request.user session.user = request.user
return core_pb2.SetSessionUserResponse(result=True) return core_pb2.SetSessionUserResponse(result=True)
@ -467,7 +468,7 @@ class CoreGrpcServer(core_pb2_grpc.CoreApiServicer):
:param context: context object :param context: context object
:return: get-session-options response about all session's options :return: get-session-options response about all session's options
""" """
logging.debug("get session options: %s", request) logger.debug("get session options: %s", request)
session = self.get_session(request.session_id, context) session = self.get_session(request.session_id, context)
current_config = session.options.get_configs() current_config = session.options.get_configs()
default_config = session.options.default_values() default_config = session.options.default_values()
@ -485,7 +486,7 @@ class CoreGrpcServer(core_pb2_grpc.CoreApiServicer):
:param context: context object :param context: context object
:return: set-session-options response :return: set-session-options response
""" """
logging.debug("set session options: %s", request) logger.debug("set session options: %s", request)
session = self.get_session(request.session_id, context) session = self.get_session(request.session_id, context)
config = session.options.get_configs() config = session.options.get_configs()
config.update(request.config) config.update(request.config)
@ -502,7 +503,7 @@ class CoreGrpcServer(core_pb2_grpc.CoreApiServicer):
:param context: context object :param context: context object
:return: get session metadata response :return: get session metadata response
""" """
logging.debug("get session metadata: %s", request) logger.debug("get session metadata: %s", request)
session = self.get_session(request.session_id, context) session = self.get_session(request.session_id, context)
return core_pb2.GetSessionMetadataResponse(config=session.metadata) return core_pb2.GetSessionMetadataResponse(config=session.metadata)
@ -516,7 +517,7 @@ class CoreGrpcServer(core_pb2_grpc.CoreApiServicer):
:param context: context object :param context: context object
:return: set metadata response :return: set metadata response
""" """
logging.debug("set session metadata: %s", request) logger.debug("set session metadata: %s", request)
session = self.get_session(request.session_id, context) session = self.get_session(request.session_id, context)
session.metadata = dict(request.config) session.metadata = dict(request.config)
return core_pb2.SetSessionMetadataResponse(result=True) return core_pb2.SetSessionMetadataResponse(result=True)
@ -544,7 +545,7 @@ class CoreGrpcServer(core_pb2_grpc.CoreApiServicer):
:param context: context object :param context: context object
:return: get-session response :return: get-session response
""" """
logging.debug("get session: %s", request) logger.debug("get session: %s", request)
session = self.get_session(request.session_id, context) session = self.get_session(request.session_id, context)
links = [] links = []
nodes = [] nodes = []
@ -718,7 +719,7 @@ class CoreGrpcServer(core_pb2_grpc.CoreApiServicer):
:param context: context object :param context: context object
:return: add-node response :return: add-node response
""" """
logging.debug("add node: %s", request) logger.debug("add node: %s", request)
session = self.get_session(request.session_id, context) session = self.get_session(request.session_id, context)
_type, _id, options = grpcutils.add_node_data(request.node) _type, _id, options = grpcutils.add_node_data(request.node)
_class = session.get_node_class(_type) _class = session.get_node_class(_type)
@ -737,7 +738,7 @@ class CoreGrpcServer(core_pb2_grpc.CoreApiServicer):
:param context: context object :param context: context object
:return: get-node response :return: get-node response
""" """
logging.debug("get node: %s", request) logger.debug("get node: %s", request)
session = self.get_session(request.session_id, context) session = self.get_session(request.session_id, context)
node = self.get_node(session, request.node_id, context, NodeBase) node = self.get_node(session, request.node_id, context, NodeBase)
ifaces = [] ifaces = []
@ -768,7 +769,7 @@ class CoreGrpcServer(core_pb2_grpc.CoreApiServicer):
options = NodeOptions() options = NodeOptions()
has_geo = request.HasField("geo") has_geo = request.HasField("geo")
if has_geo: if has_geo:
logging.info("has geo") logger.info("has geo")
lat = request.geo.lat lat = request.geo.lat
lon = request.geo.lon lon = request.geo.lon
alt = request.geo.alt alt = request.geo.alt
@ -776,7 +777,7 @@ class CoreGrpcServer(core_pb2_grpc.CoreApiServicer):
else: else:
x = request.position.x x = request.position.x
y = request.position.y y = request.position.y
logging.info("has pos: %s,%s", x, y) logger.info("has pos: %s,%s", x, y)
options.set_position(x, y) options.set_position(x, y)
session.edit_node(node.id, options) session.edit_node(node.id, options)
source = request.source if request.source else None source = request.source if request.source else None
@ -794,7 +795,7 @@ class CoreGrpcServer(core_pb2_grpc.CoreApiServicer):
:param context: context object :param context: context object
:return: edit-node response :return: edit-node response
""" """
logging.debug("edit node: %s", request) logger.debug("edit node: %s", request)
session = self.get_session(request.session_id, context) session = self.get_session(request.session_id, context)
node = self.get_node(session, request.node_id, context, NodeBase) node = self.get_node(session, request.node_id, context, NodeBase)
options = NodeOptions(icon=request.icon) options = NodeOptions(icon=request.icon)
@ -830,7 +831,7 @@ class CoreGrpcServer(core_pb2_grpc.CoreApiServicer):
:param context: context object :param context: context object
:return: core.api.grpc.core_pb2.DeleteNodeResponse :return: core.api.grpc.core_pb2.DeleteNodeResponse
""" """
logging.debug("delete node: %s", request) logger.debug("delete node: %s", request)
session = self.get_session(request.session_id, context) session = self.get_session(request.session_id, context)
result = False result = False
if request.node_id in session.nodes: if request.node_id in session.nodes:
@ -850,7 +851,7 @@ class CoreGrpcServer(core_pb2_grpc.CoreApiServicer):
:param context: context object :param context: context object
:return: core.api.grpc.core_pb2.NodeCommandResponse :return: core.api.grpc.core_pb2.NodeCommandResponse
""" """
logging.debug("sending node command: %s", request) logger.debug("sending node command: %s", request)
session = self.get_session(request.session_id, context) session = self.get_session(request.session_id, context)
node = self.get_node(session, request.node_id, context, CoreNode) node = self.get_node(session, request.node_id, context, CoreNode)
try: try:
@ -871,7 +872,7 @@ class CoreGrpcServer(core_pb2_grpc.CoreApiServicer):
:param context: context object :param context: context object
:return: get-node-terminal response :return: get-node-terminal response
""" """
logging.debug("getting node terminal: %s", request) logger.debug("getting node terminal: %s", request)
session = self.get_session(request.session_id, context) session = self.get_session(request.session_id, context)
node = self.get_node(session, request.node_id, context, CoreNode) node = self.get_node(session, request.node_id, context, CoreNode)
terminal = node.termcmdstring("/bin/bash") terminal = node.termcmdstring("/bin/bash")
@ -887,7 +888,7 @@ class CoreGrpcServer(core_pb2_grpc.CoreApiServicer):
:param context: context object :param context: context object
:return: get-node-links response :return: get-node-links response
""" """
logging.debug("get node links: %s", request) logger.debug("get node links: %s", request)
session = self.get_session(request.session_id, context) session = self.get_session(request.session_id, context)
node = self.get_node(session, request.node_id, context, NodeBase) node = self.get_node(session, request.node_id, context, NodeBase)
links = get_links(node) links = get_links(node)
@ -903,7 +904,7 @@ class CoreGrpcServer(core_pb2_grpc.CoreApiServicer):
:param context: context object :param context: context object
:return: add-link response :return: add-link response
""" """
logging.debug("add link: %s", request) logger.debug("add link: %s", request)
session = self.get_session(request.session_id, context) session = self.get_session(request.session_id, context)
node1_id = request.link.node1_id node1_id = request.link.node1_id
node2_id = request.link.node2_id node2_id = request.link.node2_id
@ -952,7 +953,7 @@ class CoreGrpcServer(core_pb2_grpc.CoreApiServicer):
:param context: context object :param context: context object
:return: edit-link response :return: edit-link response
""" """
logging.debug("edit link: %s", request) logger.debug("edit link: %s", request)
session = self.get_session(request.session_id, context) session = self.get_session(request.session_id, context)
node1_id = request.node1_id node1_id = request.node1_id
node2_id = request.node2_id node2_id = request.node2_id
@ -998,7 +999,7 @@ class CoreGrpcServer(core_pb2_grpc.CoreApiServicer):
:param context: context object :param context: context object
:return: delete-link response :return: delete-link response
""" """
logging.debug("delete link: %s", request) logger.debug("delete link: %s", request)
session = self.get_session(request.session_id, context) session = self.get_session(request.session_id, context)
node1_id = request.node1_id node1_id = request.node1_id
node2_id = request.node2_id node2_id = request.node2_id
@ -1029,7 +1030,7 @@ class CoreGrpcServer(core_pb2_grpc.CoreApiServicer):
:param context: context object :param context: context object
:return: get-hooks response about all the hooks in all session states :return: get-hooks response about all the hooks in all session states
""" """
logging.debug("get hooks: %s", request) logger.debug("get hooks: %s", request)
session = self.get_session(request.session_id, context) session = self.get_session(request.session_id, context)
hooks = grpcutils.get_hooks(session) hooks = grpcutils.get_hooks(session)
return core_pb2.GetHooksResponse(hooks=hooks) return core_pb2.GetHooksResponse(hooks=hooks)
@ -1044,7 +1045,7 @@ class CoreGrpcServer(core_pb2_grpc.CoreApiServicer):
:param context: context object :param context: context object
:return: add-hook response :return: add-hook response
""" """
logging.debug("add hook: %s", request) logger.debug("add hook: %s", request)
session = self.get_session(request.session_id, context) session = self.get_session(request.session_id, context)
hook = request.hook hook = request.hook
state = EventTypes(hook.state) state = EventTypes(hook.state)
@ -1062,7 +1063,7 @@ class CoreGrpcServer(core_pb2_grpc.CoreApiServicer):
:param context: context object :param context: context object
:return: get-mobility-configurations response that has a list of configurations :return: get-mobility-configurations response that has a list of configurations
""" """
logging.debug("get mobility configs: %s", request) logger.debug("get mobility configs: %s", request)
session = self.get_session(request.session_id, context) session = self.get_session(request.session_id, context)
configs = grpcutils.get_mobility_configs(session) configs = grpcutils.get_mobility_configs(session)
return GetMobilityConfigsResponse(configs=configs) return GetMobilityConfigsResponse(configs=configs)
@ -1078,7 +1079,7 @@ class CoreGrpcServer(core_pb2_grpc.CoreApiServicer):
:param context: context object :param context: context object
:return: get-mobility-configuration response :return: get-mobility-configuration response
""" """
logging.debug("get mobility config: %s", request) logger.debug("get mobility config: %s", request)
session = self.get_session(request.session_id, context) session = self.get_session(request.session_id, context)
current_config = session.mobility.get_model_config( current_config = session.mobility.get_model_config(
request.node_id, Ns2ScriptedMobility.name request.node_id, Ns2ScriptedMobility.name
@ -1097,7 +1098,7 @@ class CoreGrpcServer(core_pb2_grpc.CoreApiServicer):
:param context: context object :param context: context object
:return: set-mobility-configuration response :return: set-mobility-configuration response
""" """
logging.debug("set mobility config: %s", request) logger.debug("set mobility config: %s", request)
session = self.get_session(request.session_id, context) session = self.get_session(request.session_id, context)
mobility_config = request.mobility_config mobility_config = request.mobility_config
session.mobility.set_model_config( session.mobility.set_model_config(
@ -1116,7 +1117,7 @@ class CoreGrpcServer(core_pb2_grpc.CoreApiServicer):
:param context: context object :param context: context object
:return: mobility-action response :return: mobility-action response
""" """
logging.debug("mobility action: %s", request) logger.debug("mobility action: %s", request)
session = self.get_session(request.session_id, context) session = self.get_session(request.session_id, context)
node = grpcutils.get_mobility_node(session, request.node_id, context) node = grpcutils.get_mobility_node(session, request.node_id, context)
if not node.mobility: if not node.mobility:
@ -1144,7 +1145,7 @@ class CoreGrpcServer(core_pb2_grpc.CoreApiServicer):
:param context: context object :param context: context object
:return: get-services response :return: get-services response
""" """
logging.debug("get services: %s", request) logger.debug("get services: %s", request)
services = [] services = []
for name in ServiceManager.services: for name in ServiceManager.services:
service = ServiceManager.services[name] service = ServiceManager.services[name]
@ -1162,7 +1163,7 @@ class CoreGrpcServer(core_pb2_grpc.CoreApiServicer):
:param context: context object :param context: context object
:return: get-service-defaults response about all the available default services :return: get-service-defaults response about all the available default services
""" """
logging.debug("get service defaults: %s", request) logger.debug("get service defaults: %s", request)
session = self.get_session(request.session_id, context) session = self.get_session(request.session_id, context)
defaults = grpcutils.get_default_services(session) defaults = grpcutils.get_default_services(session)
return GetServiceDefaultsResponse(defaults=defaults) return GetServiceDefaultsResponse(defaults=defaults)
@ -1177,7 +1178,7 @@ class CoreGrpcServer(core_pb2_grpc.CoreApiServicer):
:param context: context object :param context: context object
:return: set-service-defaults response :return: set-service-defaults response
""" """
logging.debug("set service defaults: %s", request) logger.debug("set service defaults: %s", request)
session = self.get_session(request.session_id, context) session = self.get_session(request.session_id, context)
session.services.default_services.clear() session.services.default_services.clear()
for service_defaults in request.defaults: for service_defaults in request.defaults:
@ -1197,7 +1198,7 @@ class CoreGrpcServer(core_pb2_grpc.CoreApiServicer):
:param context: context object :param context: context object
:return: all node service configs response :return: all node service configs response
""" """
logging.debug("get node service configs: %s", request) logger.debug("get node service configs: %s", request)
session = self.get_session(request.session_id, context) session = self.get_session(request.session_id, context)
configs = grpcutils.get_node_service_configs(session) configs = grpcutils.get_node_service_configs(session)
return GetNodeServiceConfigsResponse(configs=configs) return GetNodeServiceConfigsResponse(configs=configs)
@ -1213,7 +1214,7 @@ class CoreGrpcServer(core_pb2_grpc.CoreApiServicer):
:param context: context object :param context: context object
:return: get-node-service response about the requested service :return: get-node-service response about the requested service
""" """
logging.debug("get node service: %s", request) logger.debug("get node service: %s", request)
session = self.get_session(request.session_id, context) session = self.get_session(request.session_id, context)
service = session.services.get_service( service = session.services.get_service(
request.node_id, request.service, default_service=True request.node_id, request.service, default_service=True
@ -1232,7 +1233,7 @@ class CoreGrpcServer(core_pb2_grpc.CoreApiServicer):
:param context: context object :param context: context object
:return: get-node-service response about the requested service :return: get-node-service response about the requested service
""" """
logging.debug("get node service file: %s", request) logger.debug("get node service file: %s", request)
session = self.get_session(request.session_id, context) session = self.get_session(request.session_id, context)
node = self.get_node(session, request.node_id, context, CoreNode) node = self.get_node(session, request.node_id, context, CoreNode)
file_data = session.services.get_service_file( file_data = session.services.get_service_file(
@ -1251,7 +1252,7 @@ class CoreGrpcServer(core_pb2_grpc.CoreApiServicer):
:param context: context object :param context: context object
:return: set-node-service response :return: set-node-service response
""" """
logging.debug("set node service: %s", request) logger.debug("set node service: %s", request)
session = self.get_session(request.session_id, context) session = self.get_session(request.session_id, context)
config = request.config config = request.config
grpcutils.service_configuration(session, config) grpcutils.service_configuration(session, config)
@ -1268,7 +1269,7 @@ class CoreGrpcServer(core_pb2_grpc.CoreApiServicer):
:param context: context object :param context: context object
:return: set-node-service-file response :return: set-node-service-file response
""" """
logging.debug("set node service file: %s", request) logger.debug("set node service file: %s", request)
session = self.get_session(request.session_id, context) session = self.get_session(request.session_id, context)
config = request.config config = request.config
session.services.set_service_file( session.services.set_service_file(
@ -1287,7 +1288,7 @@ class CoreGrpcServer(core_pb2_grpc.CoreApiServicer):
:param context: context object :param context: context object
:return: service-action response about status of action :return: service-action response about status of action
""" """
logging.debug("service action: %s", request) logger.debug("service action: %s", request)
session = self.get_session(request.session_id, context) session = self.get_session(request.session_id, context)
node = self.get_node(session, request.node_id, context, CoreNode) node = self.get_node(session, request.node_id, context, CoreNode)
service = None service = None
@ -1327,7 +1328,7 @@ class CoreGrpcServer(core_pb2_grpc.CoreApiServicer):
:param context: core.api.grpc.core_pb2.GetWlanConfigResponse :param context: core.api.grpc.core_pb2.GetWlanConfigResponse
:return: all wlan configurations :return: all wlan configurations
""" """
logging.debug("get wlan configs: %s", request) logger.debug("get wlan configs: %s", request)
session = self.get_session(request.session_id, context) session = self.get_session(request.session_id, context)
configs = grpcutils.get_wlan_configs(session) configs = grpcutils.get_wlan_configs(session)
return GetWlanConfigsResponse(configs=configs) return GetWlanConfigsResponse(configs=configs)
@ -1342,7 +1343,7 @@ class CoreGrpcServer(core_pb2_grpc.CoreApiServicer):
:param context: core.api.grpc.core_pb2.GetWlanConfigResponse :param context: core.api.grpc.core_pb2.GetWlanConfigResponse
:return: get-wlan-configuration response about the wlan configuration of a node :return: get-wlan-configuration response about the wlan configuration of a node
""" """
logging.debug("get wlan config: %s", request) logger.debug("get wlan config: %s", request)
session = self.get_session(request.session_id, context) session = self.get_session(request.session_id, context)
current_config = session.mobility.get_model_config( current_config = session.mobility.get_model_config(
request.node_id, BasicRangeModel.name request.node_id, BasicRangeModel.name
@ -1360,7 +1361,7 @@ class CoreGrpcServer(core_pb2_grpc.CoreApiServicer):
:param context: context object :param context: context object
:return: set-wlan-configuration response :return: set-wlan-configuration response
""" """
logging.debug("set wlan config: %s", request) logger.debug("set wlan config: %s", request)
session = self.get_session(request.session_id, context) session = self.get_session(request.session_id, context)
node_id = request.wlan_config.node_id node_id = request.wlan_config.node_id
config = request.wlan_config.config config = request.wlan_config.config
@ -1380,7 +1381,7 @@ class CoreGrpcServer(core_pb2_grpc.CoreApiServicer):
:param context: context object :param context: context object
:return: get-EMANE-configuration response :return: get-EMANE-configuration response
""" """
logging.debug("get emane config: %s", request) logger.debug("get emane config: %s", request)
session = self.get_session(request.session_id, context) session = self.get_session(request.session_id, context)
config = grpcutils.get_emane_config(session) config = grpcutils.get_emane_config(session)
return GetEmaneConfigResponse(config=config) return GetEmaneConfigResponse(config=config)
@ -1395,7 +1396,7 @@ class CoreGrpcServer(core_pb2_grpc.CoreApiServicer):
:param context: context object :param context: context object
:return: set-EMANE-configuration response :return: set-EMANE-configuration response
""" """
logging.debug("set emane config: %s", request) logger.debug("set emane config: %s", request)
session = self.get_session(request.session_id, context) session = self.get_session(request.session_id, context)
config = session.emane.get_configs() config = session.emane.get_configs()
config.update(request.config) config.update(request.config)
@ -1411,7 +1412,7 @@ class CoreGrpcServer(core_pb2_grpc.CoreApiServicer):
:param context: context object :param context: context object
:return: get-EMANE-models response that has all the models :return: get-EMANE-models response that has all the models
""" """
logging.debug("get emane models: %s", request) logger.debug("get emane models: %s", request)
session = self.get_session(request.session_id, context) session = self.get_session(request.session_id, context)
models = grpcutils.get_emane_models(session) models = grpcutils.get_emane_models(session)
return GetEmaneModelsResponse(models=models) return GetEmaneModelsResponse(models=models)
@ -1427,7 +1428,7 @@ class CoreGrpcServer(core_pb2_grpc.CoreApiServicer):
:param context: context object :param context: context object
:return: get-EMANE-model-configuration response :return: get-EMANE-model-configuration response
""" """
logging.debug("get emane model config: %s", request) logger.debug("get emane model config: %s", request)
session = self.get_session(request.session_id, context) session = self.get_session(request.session_id, context)
model = session.emane.models.get(request.model) model = session.emane.models.get(request.model)
if not model: if not model:
@ -1448,7 +1449,7 @@ class CoreGrpcServer(core_pb2_grpc.CoreApiServicer):
:param context: context object :param context: context object
:return: set-EMANE-model-configuration response :return: set-EMANE-model-configuration response
""" """
logging.debug("set emane model config: %s", request) logger.debug("set emane model config: %s", request)
session = self.get_session(request.session_id, context) session = self.get_session(request.session_id, context)
model_config = request.emane_model_config model_config = request.emane_model_config
_id = utils.iface_config_id(model_config.node_id, model_config.iface_id) _id = utils.iface_config_id(model_config.node_id, model_config.iface_id)
@ -1467,7 +1468,7 @@ class CoreGrpcServer(core_pb2_grpc.CoreApiServicer):
:return: get-EMANE-model-configurations response that has all the EMANE :return: get-EMANE-model-configurations response that has all the EMANE
configurations configurations
""" """
logging.debug("get emane model configs: %s", request) logger.debug("get emane model configs: %s", request)
session = self.get_session(request.session_id, context) session = self.get_session(request.session_id, context)
configs = grpcutils.get_emane_model_configs(session) configs = grpcutils.get_emane_model_configs(session)
return GetEmaneModelConfigsResponse(configs=configs) return GetEmaneModelConfigsResponse(configs=configs)
@ -1482,7 +1483,7 @@ class CoreGrpcServer(core_pb2_grpc.CoreApiServicer):
:param context: context object :param context: context object
:return: save-xml response :return: save-xml response
""" """
logging.debug("save xml: %s", request) logger.debug("save xml: %s", request)
session = self.get_session(request.session_id, context) session = self.get_session(request.session_id, context)
_, temp_path = tempfile.mkstemp() _, temp_path = tempfile.mkstemp()
@ -1503,7 +1504,7 @@ class CoreGrpcServer(core_pb2_grpc.CoreApiServicer):
:param context: context object :param context: context object
:return: Open-XML response or raise an exception if invalid XML file :return: Open-XML response or raise an exception if invalid XML file
""" """
logging.debug("open xml: %s", request) logger.debug("open xml: %s", request)
session = self.coreemu.create_session() session = self.coreemu.create_session()
temp = tempfile.NamedTemporaryFile(delete=False) temp = tempfile.NamedTemporaryFile(delete=False)
temp.write(request.data.encode("utf-8")) temp.write(request.data.encode("utf-8"))
@ -1516,7 +1517,7 @@ class CoreGrpcServer(core_pb2_grpc.CoreApiServicer):
session.file_path = file_path session.file_path = file_path
return core_pb2.OpenXmlResponse(session_id=session.id, result=True) return core_pb2.OpenXmlResponse(session_id=session.id, result=True)
except IOError: except IOError:
logging.exception("error opening session file") logger.exception("error opening session file")
self.coreemu.delete_session(session.id) self.coreemu.delete_session(session.id)
context.abort(grpc.StatusCode.INVALID_ARGUMENT, "invalid xml file") context.abort(grpc.StatusCode.INVALID_ARGUMENT, "invalid xml file")
finally: finally:
@ -1549,7 +1550,7 @@ class CoreGrpcServer(core_pb2_grpc.CoreApiServicer):
:param context: context object :param context: context object
:return: emane link response with success status :return: emane link response with success status
""" """
logging.debug("emane link: %s", request) logger.debug("emane link: %s", request)
session = self.get_session(request.session_id, context) session = self.get_session(request.session_id, context)
nem1 = request.nem1 nem1 = request.nem1
iface1 = session.emane.get_iface(nem1) iface1 = session.emane.get_iface(nem1)

212
daemon/core/api/tlv/corehandlers.py
View file

@ -55,6 +55,8 @@ from core.nodes.network import WlanNode
from core.nodes.physical import Rj45Node from core.nodes.physical import Rj45Node
from core.services.coreservices import ServiceManager, ServiceShim from core.services.coreservices import ServiceManager, ServiceShim
logger = logging.getLogger(__name__)
class CoreHandler(socketserver.BaseRequestHandler): class CoreHandler(socketserver.BaseRequestHandler):
""" """
@ -104,7 +106,7 @@ class CoreHandler(socketserver.BaseRequestHandler):
:return: nothing :return: nothing
""" """
logging.debug("new TCP connection: %s", self.client_address) logger.debug("new TCP connection: %s", self.client_address)
def finish(self): def finish(self):
""" """
@ -113,40 +115,40 @@ class CoreHandler(socketserver.BaseRequestHandler):
:return: nothing :return: nothing
""" """
logging.debug("finishing request handler") logger.debug("finishing request handler")
logging.debug("remaining message queue size: %s", self.message_queue.qsize()) logger.debug("remaining message queue size: %s", self.message_queue.qsize())
# give some time for message queue to deplete # give some time for message queue to deplete
timeout = 10 timeout = 10
wait = 0 wait = 0
while not self.message_queue.empty(): while not self.message_queue.empty():
logging.debug("waiting for message queue to empty: %s seconds", wait) logger.debug("waiting for message queue to empty: %s seconds", wait)
time.sleep(1) time.sleep(1)
wait += 1 wait += 1
if wait == timeout: if wait == timeout:
logging.warning("queue failed to be empty, finishing request handler") logger.warning("queue failed to be empty, finishing request handler")
break break
logging.info("client disconnected: notifying threads") logger.info("client disconnected: notifying threads")
self.done = True self.done = True
for thread in self.handler_threads: for thread in self.handler_threads:
logging.info("waiting for thread: %s", thread.getName()) logger.info("waiting for thread: %s", thread.getName())
thread.join(timeout) thread.join(timeout)
if thread.is_alive(): if thread.is_alive():
logging.warning( logger.warning(
"joining %s failed: still alive after %s sec", "joining %s failed: still alive after %s sec",
thread.getName(), thread.getName(),
timeout, timeout,
) )
logging.info("connection closed: %s", self.client_address) logger.info("connection closed: %s", self.client_address)
if self.session: if self.session:
# remove client from session broker and shutdown if there are no clients # remove client from session broker and shutdown if there are no clients
self.remove_session_handlers() self.remove_session_handlers()
clients = self.session_clients[self.session.id] clients = self.session_clients[self.session.id]
clients.remove(self) clients.remove(self)
if not clients and not self.session.is_active(): if not clients and not self.session.is_active():
logging.info( logger.info(
"no session clients left and not active, initiating shutdown" "no session clients left and not active, initiating shutdown"
) )
self.coreemu.delete_session(self.session.id) self.coreemu.delete_session(self.session.id)
@ -218,7 +220,7 @@ class CoreHandler(socketserver.BaseRequestHandler):
:param core.emulator.data.EventData event_data: event data to handle :param core.emulator.data.EventData event_data: event data to handle
:return: nothing :return: nothing
""" """
logging.debug("handling broadcast event: %s", event_data) logger.debug("handling broadcast event: %s", event_data)
tlv_data = structutils.pack_values( tlv_data = structutils.pack_values(
coreapi.CoreEventTlv, coreapi.CoreEventTlv,
@ -236,7 +238,7 @@ class CoreHandler(socketserver.BaseRequestHandler):
try: try:
self.sendall(message) self.sendall(message)
except IOError: except IOError:
logging.exception("error sending event message") logger.exception("error sending event message")
def handle_broadcast_file(self, file_data): def handle_broadcast_file(self, file_data):
""" """
@ -245,7 +247,7 @@ class CoreHandler(socketserver.BaseRequestHandler):
:param core.emulator.data.FileData file_data: file data to handle :param core.emulator.data.FileData file_data: file data to handle
:return: nothing :return: nothing
""" """
logging.debug("handling broadcast file: %s", file_data) logger.debug("handling broadcast file: %s", file_data)
tlv_data = structutils.pack_values( tlv_data = structutils.pack_values(
coreapi.CoreFileTlv, coreapi.CoreFileTlv,
@ -266,7 +268,7 @@ class CoreHandler(socketserver.BaseRequestHandler):
try: try:
self.sendall(message) self.sendall(message)
except IOError: except IOError:
logging.exception("error sending file message") logger.exception("error sending file message")
def handle_broadcast_config(self, config_data): def handle_broadcast_config(self, config_data):
""" """
@ -275,12 +277,12 @@ class CoreHandler(socketserver.BaseRequestHandler):
:param core.emulator.data.ConfigData config_data: config data to handle :param core.emulator.data.ConfigData config_data: config data to handle
:return: nothing :return: nothing
""" """
logging.debug("handling broadcast config: %s", config_data) logger.debug("handling broadcast config: %s", config_data)
message = dataconversion.convert_config(config_data) message = dataconversion.convert_config(config_data)
try: try:
self.sendall(message) self.sendall(message)
except IOError: except IOError:
logging.exception("error sending config message") logger.exception("error sending config message")
def handle_broadcast_exception(self, exception_data): def handle_broadcast_exception(self, exception_data):
""" """
@ -289,7 +291,7 @@ class CoreHandler(socketserver.BaseRequestHandler):
:param core.emulator.data.ExceptionData exception_data: exception data to handle :param core.emulator.data.ExceptionData exception_data: exception data to handle
:return: nothing :return: nothing
""" """
logging.debug("handling broadcast exception: %s", exception_data) logger.debug("handling broadcast exception: %s", exception_data)
tlv_data = structutils.pack_values( tlv_data = structutils.pack_values(
coreapi.CoreExceptionTlv, coreapi.CoreExceptionTlv,
[ [
@ -306,7 +308,7 @@ class CoreHandler(socketserver.BaseRequestHandler):
try: try:
self.sendall(message) self.sendall(message)
except IOError: except IOError:
logging.exception("error sending exception message") logger.exception("error sending exception message")
def handle_broadcast_node(self, node_data): def handle_broadcast_node(self, node_data):
""" """
@ -315,12 +317,12 @@ class CoreHandler(socketserver.BaseRequestHandler):
:param core.emulator.data.NodeData node_data: node data to handle :param core.emulator.data.NodeData node_data: node data to handle
:return: nothing :return: nothing
""" """
logging.debug("handling broadcast node: %s", node_data) logger.debug("handling broadcast node: %s", node_data)
message = dataconversion.convert_node(node_data) message = dataconversion.convert_node(node_data)
try: try:
self.sendall(message) self.sendall(message)
except IOError: except IOError:
logging.exception("error sending node message") logger.exception("error sending node message")
def handle_broadcast_link(self, link_data): def handle_broadcast_link(self, link_data):
""" """
@ -329,7 +331,7 @@ class CoreHandler(socketserver.BaseRequestHandler):
:param core.emulator.data.LinkData link_data: link data to handle :param core.emulator.data.LinkData link_data: link data to handle
:return: nothing :return: nothing
""" """
logging.debug("handling broadcast link: %s", link_data) logger.debug("handling broadcast link: %s", link_data)
options_data = link_data.options options_data = link_data.options
loss = "" loss = ""
if options_data.loss is not None: if options_data.loss is not None:
@ -381,7 +383,7 @@ class CoreHandler(socketserver.BaseRequestHandler):
try: try:
self.sendall(message) self.sendall(message)
except IOError: except IOError:
logging.exception("error sending Event Message") logger.exception("error sending Event Message")
def register(self): def register(self):
""" """
@ -389,7 +391,7 @@ class CoreHandler(socketserver.BaseRequestHandler):
:return: register message data :return: register message data
""" """
logging.info( logger.info(
"GUI has connected to session %d at %s", self.session.id, time.ctime() "GUI has connected to session %d at %s", self.session.id, time.ctime()
) )
tlv_data = b"" tlv_data = b""
@ -461,14 +463,14 @@ class CoreHandler(socketserver.BaseRequestHandler):
header header
) )
if message_len == 0: if message_len == 0:
logging.warning("received message with no data") logger.warning("received message with no data")
data = b"" data = b""
while len(data) < message_len: while len(data) < message_len:
data += self.request.recv(message_len - len(data)) data += self.request.recv(message_len - len(data))
if len(data) > message_len: if len(data) > message_len:
error_message = f"received message length does not match received data ({len(data)} != {message_len})" error_message = f"received message length does not match received data ({len(data)} != {message_len})"
logging.error(error_message) logger.error(error_message)
raise IOError(error_message) raise IOError(error_message)
try: try:
@ -477,7 +479,7 @@ class CoreHandler(socketserver.BaseRequestHandler):
except KeyError: except KeyError:
message = coreapi.CoreMessage(message_flags, header, data) message = coreapi.CoreMessage(message_flags, header, data)
message.message_type = message_type message.message_type = message_type
logging.exception("unimplemented core message type: %s", message.type_str()) logger.exception("unimplemented core message type: %s", message.type_str())
return message return message
@ -488,7 +490,7 @@ class CoreHandler(socketserver.BaseRequestHandler):
:param message: message to queue :param message: message to queue
:return: nothing :return: nothing
""" """
logging.debug( logger.debug(
"queueing msg (queuedtimes = %s): type %s", "queueing msg (queuedtimes = %s): type %s",
message.queuedtimes, message.queuedtimes,
MessageTypes(message.message_type), MessageTypes(message.message_type),
@ -518,11 +520,11 @@ class CoreHandler(socketserver.BaseRequestHandler):
:param message: message to handle :param message: message to handle
:return: nothing :return: nothing
""" """
logging.debug( logger.debug(
"%s handling message:\n%s", threading.currentThread().getName(), message "%s handling message:\n%s", threading.currentThread().getName(), message
) )
if message.message_type not in self.message_handlers: if message.message_type not in self.message_handlers:
logging.error("no handler for message type: %s", message.type_str()) logger.error("no handler for message type: %s", message.type_str())
return return
message_handler = self.message_handlers[message.message_type] message_handler = self.message_handlers[message.message_type]
@ -532,7 +534,7 @@ class CoreHandler(socketserver.BaseRequestHandler):
self.dispatch_replies(replies, message) self.dispatch_replies(replies, message)
except Exception as e: except Exception as e:
self.send_exception(ExceptionLevels.ERROR, "corehandler", str(e)) self.send_exception(ExceptionLevels.ERROR, "corehandler", str(e))
logging.exception( logger.exception(
"%s: exception while handling message: %s", "%s: exception while handling message: %s",
threading.currentThread().getName(), threading.currentThread().getName(),
message, message,
@ -560,12 +562,12 @@ class CoreHandler(socketserver.BaseRequestHandler):
# multiple TLVs of same type cause KeyError exception # multiple TLVs of same type cause KeyError exception
reply_message = f"CoreMessage (type {message_type} flags {message_flags} length {message_length})" reply_message = f"CoreMessage (type {message_type} flags {message_flags} length {message_length})"
logging.debug("sending reply:\n%s", reply_message) logger.debug("sending reply:\n%s", reply_message)
try: try:
self.sendall(reply) self.sendall(reply)
except IOError: except IOError:
logging.exception("error dispatching reply") logger.exception("error dispatching reply")
def handle(self): def handle(self):
""" """
@ -580,7 +582,7 @@ class CoreHandler(socketserver.BaseRequestHandler):
# TODO: add shutdown handler for session # TODO: add shutdown handler for session
self.session = self.coreemu.create_session(port) self.session = self.coreemu.create_session(port)
logging.debug("created new session for client: %s", self.session.id) logger.debug("created new session for client: %s", self.session.id)
clients = self.session_clients.setdefault(self.session.id, []) clients = self.session_clients.setdefault(self.session.id, [])
clients.append(self) clients.append(self)
@ -594,10 +596,10 @@ class CoreHandler(socketserver.BaseRequestHandler):
try: try:
message = self.receive_message() message = self.receive_message()
except EOFError: except EOFError:
logging.info("client disconnected") logger.info("client disconnected")
break break
except IOError: except IOError:
logging.exception("error receiving message") logger.exception("error receiving message")
break break
message.queuedtimes = 0 message.queuedtimes = 0
@ -619,7 +621,7 @@ class CoreHandler(socketserver.BaseRequestHandler):
if client == self: if client == self:
continue continue
logging.debug("BROADCAST TO OTHER CLIENT: %s", client) logger.debug("BROADCAST TO OTHER CLIENT: %s", client)
client.sendall(message.raw_message) client.sendall(message.raw_message)
def send_exception(self, level, source, text, node=None): def send_exception(self, level, source, text, node=None):
@ -643,7 +645,7 @@ class CoreHandler(socketserver.BaseRequestHandler):
self.handle_broadcast_exception(exception_data) self.handle_broadcast_exception(exception_data)
def add_session_handlers(self): def add_session_handlers(self):
logging.debug("adding session broadcast handlers") logger.debug("adding session broadcast handlers")
self.session.event_handlers.append(self.handle_broadcast_event) self.session.event_handlers.append(self.handle_broadcast_event)
self.session.exception_handlers.append(self.handle_broadcast_exception) self.session.exception_handlers.append(self.handle_broadcast_exception)
self.session.node_handlers.append(self.handle_broadcast_node) self.session.node_handlers.append(self.handle_broadcast_node)
@ -652,7 +654,7 @@ class CoreHandler(socketserver.BaseRequestHandler):
self.session.config_handlers.append(self.handle_broadcast_config) self.session.config_handlers.append(self.handle_broadcast_config)
def remove_session_handlers(self): def remove_session_handlers(self):
logging.debug("removing session broadcast handlers") logger.debug("removing session broadcast handlers")
self.session.event_handlers.remove(self.handle_broadcast_event) self.session.event_handlers.remove(self.handle_broadcast_event)
self.session.exception_handlers.remove(self.handle_broadcast_exception) self.session.exception_handlers.remove(self.handle_broadcast_exception)
self.session.node_handlers.remove(self.handle_broadcast_node) self.session.node_handlers.remove(self.handle_broadcast_node)
@ -672,7 +674,7 @@ class CoreHandler(socketserver.BaseRequestHandler):
message.flags & MessageFlags.ADD.value message.flags & MessageFlags.ADD.value
and message.flags & MessageFlags.DELETE.value and message.flags & MessageFlags.DELETE.value
): ):
logging.warning("ignoring invalid message: add and delete flag both set") logger.warning("ignoring invalid message: add and delete flag both set")
return () return ()
_class = CoreNode _class = CoreNode
@ -898,7 +900,7 @@ class CoreHandler(socketserver.BaseRequestHandler):
else: else:
node.cmd(command, wait=False) node.cmd(command, wait=False)
except CoreError: except CoreError:
logging.exception("error getting object: %s", node_id) logger.exception("error getting object: %s", node_id)
# XXX wait and queue this message to try again later # XXX wait and queue this message to try again later
# XXX maybe this should be done differently # XXX maybe this should be done differently
if not message.flags & MessageFlags.LOCAL.value: if not message.flags & MessageFlags.LOCAL.value:
@ -920,7 +922,7 @@ class CoreHandler(socketserver.BaseRequestHandler):
execute_server = message.get_tlv(RegisterTlvs.EXECUTE_SERVER.value) execute_server = message.get_tlv(RegisterTlvs.EXECUTE_SERVER.value)
if execute_server: if execute_server:
try: try:
logging.info("executing: %s", execute_server) logger.info("executing: %s", execute_server)
if message.flags & MessageFlags.STRING.value: if message.flags & MessageFlags.STRING.value:
old_session_ids = set(self.coreemu.sessions.keys()) old_session_ids = set(self.coreemu.sessions.keys())
sys.argv = shlex.split(execute_server) sys.argv = shlex.split(execute_server)
@ -946,26 +948,26 @@ class CoreHandler(socketserver.BaseRequestHandler):
new_sid = new_session_ids.difference(old_session_ids) new_sid = new_session_ids.difference(old_session_ids)
try: try:
sid = new_sid.pop() sid = new_sid.pop()
logging.info("executed: %s as session %d", execute_server, sid) logger.info("executed: %s as session %d", execute_server, sid)
except KeyError: except KeyError:
logging.info( logger.info(
"executed %s with unknown session ID", execute_server "executed %s with unknown session ID", execute_server
) )
return replies return replies
logging.debug("checking session %d for RUNTIME state", sid) logger.debug("checking session %d for RUNTIME state", sid)
session = self.coreemu.sessions.get(sid) session = self.coreemu.sessions.get(sid)
retries = 10 retries = 10
# wait for session to enter RUNTIME state, to prevent GUI from # wait for session to enter RUNTIME state, to prevent GUI from
# connecting while nodes are still being instantiated # connecting while nodes are still being instantiated
while session.state != EventTypes.RUNTIME_STATE: while session.state != EventTypes.RUNTIME_STATE:
logging.debug( logger.debug(
"waiting for session %d to enter RUNTIME state", sid "waiting for session %d to enter RUNTIME state", sid
) )
time.sleep(1) time.sleep(1)
retries -= 1 retries -= 1
if retries <= 0: if retries <= 0:
logging.debug("session %d did not enter RUNTIME state", sid) logger.debug("session %d did not enter RUNTIME state", sid)
return replies return replies
tlv_data = coreapi.CoreRegisterTlv.pack( tlv_data = coreapi.CoreRegisterTlv.pack(
@ -977,7 +979,7 @@ class CoreHandler(socketserver.BaseRequestHandler):
message = coreapi.CoreRegMessage.pack(0, tlv_data) message = coreapi.CoreRegMessage.pack(0, tlv_data)
replies.append(message) replies.append(message)
except Exception as e: except Exception as e:
logging.exception("error executing: %s", execute_server) logger.exception("error executing: %s", execute_server)
tlv_data = coreapi.CoreExceptionTlv.pack(ExceptionTlvs.LEVEL.value, 2) tlv_data = coreapi.CoreExceptionTlv.pack(ExceptionTlvs.LEVEL.value, 2)
tlv_data += coreapi.CoreExceptionTlv.pack( tlv_data += coreapi.CoreExceptionTlv.pack(
ExceptionTlvs.TEXT.value, str(e) ExceptionTlvs.TEXT.value, str(e)
@ -989,7 +991,7 @@ class CoreHandler(socketserver.BaseRequestHandler):
gui = message.get_tlv(RegisterTlvs.GUI.value) gui = message.get_tlv(RegisterTlvs.GUI.value)
if gui is None: if gui is None:
logging.debug("ignoring Register message") logger.debug("ignoring Register message")
else: else:
# register capabilities with the GUI # register capabilities with the GUI
replies.append(self.register()) replies.append(self.register())
@ -1020,7 +1022,7 @@ class CoreHandler(socketserver.BaseRequestHandler):
network_id=message.get_tlv(ConfigTlvs.NETWORK_ID.value), network_id=message.get_tlv(ConfigTlvs.NETWORK_ID.value),
opaque=message.get_tlv(ConfigTlvs.OPAQUE.value), opaque=message.get_tlv(ConfigTlvs.OPAQUE.value),
) )
logging.debug( logger.debug(
"configuration message for %s node %s", config_data.object, config_data.node "configuration message for %s node %s", config_data.object, config_data.node
) )
message_type = ConfigFlags(config_data.type) message_type = ConfigFlags(config_data.type)
@ -1095,7 +1097,7 @@ class CoreHandler(socketserver.BaseRequestHandler):
self.session.location.reset() self.session.location.reset()
else: else:
if not config_data.data_values: if not config_data.data_values:
logging.warning("location data missing") logger.warning("location data missing")
else: else:
values = [float(x) for x in config_data.data_values.split("|")] values = [float(x) for x in config_data.data_values.split("|")]
@ -1108,7 +1110,7 @@ class CoreHandler(socketserver.BaseRequestHandler):
# geographic reference point # geographic reference point
self.session.location.setrefgeo(lat, lon, alt) self.session.location.setrefgeo(lat, lon, alt)
self.session.location.refscale = values[5] self.session.location.refscale = values[5]
logging.info( logger.info(
"location configured: %s = %s scale=%s", "location configured: %s = %s scale=%s",
self.session.location.refxyz, self.session.location.refxyz,
self.session.location.refgeo, self.session.location.refgeo,
@ -1145,7 +1147,7 @@ class CoreHandler(socketserver.BaseRequestHandler):
def handle_config_broker(self, message_type, config_data): def handle_config_broker(self, message_type, config_data):
if message_type not in [ConfigFlags.REQUEST, ConfigFlags.RESET]: if message_type not in [ConfigFlags.REQUEST, ConfigFlags.RESET]:
if not config_data.data_values: if not config_data.data_values:
logging.info("emulation server data missing") logger.info("emulation server data missing")
else: else:
values = config_data.data_values.split("|") values = config_data.data_values.split("|")
@ -1169,7 +1171,7 @@ class CoreHandler(socketserver.BaseRequestHandler):
session_id = config_data.session session_id = config_data.session
opaque = config_data.opaque opaque = config_data.opaque
logging.debug( logger.debug(
"configuration request: node(%s) session(%s) opaque(%s)", "configuration request: node(%s) session(%s) opaque(%s)",
node_id, node_id,
session_id, session_id,
@ -1199,10 +1201,10 @@ class CoreHandler(socketserver.BaseRequestHandler):
values = [] values = []
group_strings = [] group_strings = []
start_index = 1 start_index = 1
logging.debug("sorted groups: %s", groups) logger.debug("sorted groups: %s", groups)
for group in groups: for group in groups:
services = sorted(group_map[group], key=lambda x: x.name.lower()) services = sorted(group_map[group], key=lambda x: x.name.lower())
logging.debug("sorted services for group(%s): %s", group, services) logger.debug("sorted services for group(%s): %s", group, services)
end_index = start_index + len(services) - 1 end_index = start_index + len(services) - 1
group_strings.append(f"{group}:{start_index}-{end_index}") group_strings.append(f"{group}:{start_index}-{end_index}")
start_index += len(services) start_index += len(services)
@ -1226,7 +1228,7 @@ class CoreHandler(socketserver.BaseRequestHandler):
node = self.session.get_node(node_id, CoreNodeBase) node = self.session.get_node(node_id, CoreNodeBase)
if node is None: if node is None:
logging.warning( logger.warning(
"request to configure service for unknown node %s", node_id "request to configure service for unknown node %s", node_id
) )
return replies return replies
@ -1285,7 +1287,7 @@ class CoreHandler(socketserver.BaseRequestHandler):
error_message = "services config message that I don't know how to handle" error_message = "services config message that I don't know how to handle"
if values is None: if values is None:
logging.error(error_message) logger.error(error_message)
else: else:
if opaque is None: if opaque is None:
values = values.split("|") values = values.split("|")
@ -1294,11 +1296,11 @@ class CoreHandler(socketserver.BaseRequestHandler):
data_types is None data_types is None
or data_types[0] != ConfigDataTypes.STRING.value or data_types[0] != ConfigDataTypes.STRING.value
): ):
logging.info(error_message) logger.info(error_message)
return None return None
key = values.pop(0) key = values.pop(0)
self.session.services.default_services[key] = values self.session.services.default_services[key] = values
logging.debug("default services for type %s set to %s", key, values) logger.debug("default services for type %s set to %s", key, values)
elif node_id: elif node_id:
services = ServiceShim.servicesfromopaque(opaque) services = ServiceShim.servicesfromopaque(opaque)
if services: if services:
@ -1337,16 +1339,16 @@ class CoreHandler(socketserver.BaseRequestHandler):
values_str = config_data.data_values values_str = config_data.data_values
node_id = utils.iface_config_id(node_id, iface_id) node_id = utils.iface_config_id(node_id, iface_id)
logging.debug( logger.debug(
"received configure message for %s nodenum: %s", object_name, node_id "received configure message for %s nodenum: %s", object_name, node_id
) )
if message_type == ConfigFlags.REQUEST: if message_type == ConfigFlags.REQUEST:
logging.info("replying to configure request for model: %s", object_name) logger.info("replying to configure request for model: %s", object_name)
typeflags = ConfigFlags.NONE.value typeflags = ConfigFlags.NONE.value
model_class = self.session.mobility.models.get(object_name) model_class = self.session.mobility.models.get(object_name)
if not model_class: if not model_class:
logging.warning("model class does not exist: %s", object_name) logger.warning("model class does not exist: %s", object_name)
return [] return []
config = self.session.mobility.get_model_config(node_id, object_name) config = self.session.mobility.get_model_config(node_id, object_name)
@ -1357,7 +1359,7 @@ class CoreHandler(socketserver.BaseRequestHandler):
elif message_type != ConfigFlags.RESET: elif message_type != ConfigFlags.RESET:
# store the configuration values for later use, when the node # store the configuration values for later use, when the node
if not object_name: if not object_name:
logging.warning("no configuration object for node: %s", node_id) logger.warning("no configuration object for node: %s", node_id)
return [] return []
parsed_config = {} parsed_config = {}
@ -1371,7 +1373,7 @@ class CoreHandler(socketserver.BaseRequestHandler):
if object_name == BasicRangeModel.name: if object_name == BasicRangeModel.name:
node.updatemodel(parsed_config) node.updatemodel(parsed_config)
except CoreError: except CoreError:
logging.error( logger.error(
"skipping mobility configuration for unknown node: %s", node_id "skipping mobility configuration for unknown node: %s", node_id
) )
@ -1385,11 +1387,11 @@ class CoreHandler(socketserver.BaseRequestHandler):
values_str = config_data.data_values values_str = config_data.data_values
node_id = utils.iface_config_id(node_id, iface_id) node_id = utils.iface_config_id(node_id, iface_id)
logging.debug( logger.debug(
"received configure message for %s nodenum: %s", object_name, node_id "received configure message for %s nodenum: %s", object_name, node_id
) )
if message_type == ConfigFlags.REQUEST: if message_type == ConfigFlags.REQUEST:
logging.info("replying to configure request for %s model", object_name) logger.info("replying to configure request for %s model", object_name)
typeflags = ConfigFlags.NONE.value typeflags = ConfigFlags.NONE.value
config = self.session.emane.get_configs() config = self.session.emane.get_configs()
config_response = ConfigShim.config_data( config_response = ConfigShim.config_data(
@ -1398,7 +1400,7 @@ class CoreHandler(socketserver.BaseRequestHandler):
replies.append(config_response) replies.append(config_response)
elif message_type != ConfigFlags.RESET: elif message_type != ConfigFlags.RESET:
if not object_name: if not object_name:
logging.info("no configuration object for node %s", node_id) logger.info("no configuration object for node %s", node_id)
return [] return []
if values_str: if values_str:
@ -1415,16 +1417,16 @@ class CoreHandler(socketserver.BaseRequestHandler):
values_str = config_data.data_values values_str = config_data.data_values
node_id = utils.iface_config_id(node_id, iface_id) node_id = utils.iface_config_id(node_id, iface_id)
logging.debug( logger.debug(
"received configure message for %s nodenum: %s", object_name, node_id "received configure message for %s nodenum: %s", object_name, node_id
) )
if message_type == ConfigFlags.REQUEST: if message_type == ConfigFlags.REQUEST:
logging.info("replying to configure request for model: %s", object_name) logger.info("replying to configure request for model: %s", object_name)
typeflags = ConfigFlags.NONE.value typeflags = ConfigFlags.NONE.value
model_class = self.session.emane.models.get(object_name) model_class = self.session.emane.models.get(object_name)
if not model_class: if not model_class:
logging.warning("model class does not exist: %s", object_name) logger.warning("model class does not exist: %s", object_name)
return [] return []
config = self.session.emane.get_model_config(node_id, object_name) config = self.session.emane.get_model_config(node_id, object_name)
@ -1435,7 +1437,7 @@ class CoreHandler(socketserver.BaseRequestHandler):
elif message_type != ConfigFlags.RESET: elif message_type != ConfigFlags.RESET:
# store the configuration values for later use, when the node # store the configuration values for later use, when the node
if not object_name: if not object_name:
logging.warning("no configuration object for node: %s", node_id) logger.warning("no configuration object for node: %s", node_id)
return [] return []
parsed_config = {} parsed_config = {}
@ -1464,13 +1466,11 @@ class CoreHandler(socketserver.BaseRequestHandler):
compressed_data = message.get_tlv(FileTlvs.COMPRESSED_DATA.value) compressed_data = message.get_tlv(FileTlvs.COMPRESSED_DATA.value)
if compressed_data: if compressed_data:
logging.warning( logger.warning("Compressed file data not implemented for File message.")
"Compressed file data not implemented for File message."
)
return () return ()
if src_path and data: if src_path and data:
logging.warning( logger.warning(
"ignoring invalid File message: source and data TLVs are both present" "ignoring invalid File message: source and data TLVs are both present"
) )
return () return ()
@ -1487,7 +1487,7 @@ class CoreHandler(socketserver.BaseRequestHandler):
elif file_type.startswith("hook:"): elif file_type.startswith("hook:"):
_, state = file_type.split(":")[:2] _, state = file_type.split(":")[:2]
if not state.isdigit(): if not state.isdigit():
logging.error("error setting hook having state '%s'", state) logger.error("error setting hook having state '%s'", state)
return () return ()
state = int(state) state = int(state)
state = EventTypes(state) state = EventTypes(state)
@ -1517,7 +1517,7 @@ class CoreHandler(socketserver.BaseRequestHandler):
:param message: interface message to handle :param message: interface message to handle
:return: reply messages :return: reply messages
""" """
logging.info("ignoring Interface message") logger.info("ignoring Interface message")
return () return ()
def handle_event_message(self, message): def handle_event_message(self, message):
@ -1543,7 +1543,7 @@ class CoreHandler(socketserver.BaseRequestHandler):
raise NotImplementedError("Event message missing event type") raise NotImplementedError("Event message missing event type")
node_id = event_data.node node_id = event_data.node
logging.debug("handling event %s at %s", event_type.name, time.ctime()) logger.debug("handling event %s at %s", event_type.name, time.ctime())
if event_type.value <= EventTypes.SHUTDOWN_STATE.value: if event_type.value <= EventTypes.SHUTDOWN_STATE.value:
if node_id is not None: if node_id is not None:
node = self.session.get_node(node_id, NodeBase) node = self.session.get_node(node_id, NodeBase)
@ -1555,7 +1555,7 @@ class CoreHandler(socketserver.BaseRequestHandler):
self.session.start_mobility(node_ids=[node.id]) self.session.start_mobility(node_ids=[node.id])
return () return ()
logging.warning( logger.warning(
"dropping unhandled event message for node: %s", node.name "dropping unhandled event message for node: %s", node.name
) )
return () return ()
@ -1580,12 +1580,12 @@ class CoreHandler(socketserver.BaseRequestHandler):
self.send_node_emulation_id(_id) self.send_node_emulation_id(_id)
elif event_type == EventTypes.RUNTIME_STATE: elif event_type == EventTypes.RUNTIME_STATE:
self.session.set_state(event_type) self.session.set_state(event_type)
logging.warning("Unexpected event message: RUNTIME state received") logger.warning("Unexpected event message: RUNTIME state received")
elif event_type == EventTypes.DATACOLLECT_STATE: elif event_type == EventTypes.DATACOLLECT_STATE:
self.session.data_collect() self.session.data_collect()
elif event_type == EventTypes.SHUTDOWN_STATE: elif event_type == EventTypes.SHUTDOWN_STATE:
self.session.set_state(event_type) self.session.set_state(event_type)
logging.warning("Unexpected event message: SHUTDOWN state received") logger.warning("Unexpected event message: SHUTDOWN state received")
elif event_type in { elif event_type in {
EventTypes.START, EventTypes.START,
EventTypes.STOP, EventTypes.STOP,
@ -1605,7 +1605,7 @@ class CoreHandler(socketserver.BaseRequestHandler):
self.session.mobility_event(event_data) self.session.mobility_event(event_data)
handled = True handled = True
if not handled: if not handled:
logging.warning( logger.warning(
"unhandled event message: event type %s, name %s ", "unhandled event message: event type %s, name %s ",
event_type.name, event_type.name,
name, name,
@ -1624,7 +1624,7 @@ class CoreHandler(socketserver.BaseRequestHandler):
name = event_data.name name = event_data.name
data = event_data.data data = event_data.data
if etime is None: if etime is None:
logging.warning("Event message scheduled event missing start time") logger.warning("Event message scheduled event missing start time")
return () return ()
if message.flags & MessageFlags.ADD.value: if message.flags & MessageFlags.ADD.value:
self.session.add_event( self.session.add_event(
@ -1650,7 +1650,7 @@ class CoreHandler(socketserver.BaseRequestHandler):
try: try:
node = self.session.get_node(node_id, CoreNodeBase) node = self.session.get_node(node_id, CoreNodeBase)
except CoreError: except CoreError:
logging.warning( logger.warning(
"ignoring event for service '%s', unknown node '%s'", name, node_id "ignoring event for service '%s', unknown node '%s'", name, node_id
) )
return return
@ -1692,7 +1692,7 @@ class CoreHandler(socketserver.BaseRequestHandler):
if num > 1: if num > 1:
unknown_data += ", " unknown_data += ", "
num -= 1 num -= 1
logging.warning("Event requested for unknown service(s): %s", unknown_data) logger.warning("Event requested for unknown service(s): %s", unknown_data)
unknown_data = f"Unknown:{unknown_data}" unknown_data = f"Unknown:{unknown_data}"
event_data = EventData( event_data = EventData(
@ -1720,7 +1720,7 @@ class CoreHandler(socketserver.BaseRequestHandler):
files = coreapi.str_to_list(file_str) files = coreapi.str_to_list(file_str)
thumb = message.get_tlv(SessionTlvs.THUMB.value) thumb = message.get_tlv(SessionTlvs.THUMB.value)
user = message.get_tlv(SessionTlvs.USER.value) user = message.get_tlv(SessionTlvs.USER.value)
logging.debug( logger.debug(
"SESSION message flags=0x%x sessions=%s", message.flags, session_id_str "SESSION message flags=0x%x sessions=%s", message.flags, session_id_str
) )
@ -1732,7 +1732,7 @@ class CoreHandler(socketserver.BaseRequestHandler):
else: else:
session = self.coreemu.sessions.get(session_id) session = self.coreemu.sessions.get(session_id)
if session is None: if session is None:
logging.warning("session %s not found", session_id) logger.warning("session %s not found", session_id)
continue continue
if names is not None: if names is not None:
session.name = names[index] session.name = names[index]
@ -1756,14 +1756,14 @@ class CoreHandler(socketserver.BaseRequestHandler):
session = self.coreemu.sessions.get(session_id) session = self.coreemu.sessions.get(session_id)
if session is None: if session is None:
logging.info( logger.info(
"session %s not found (flags=0x%x)", session_id, message.flags "session %s not found (flags=0x%x)", session_id, message.flags
) )
continue continue
if message.flags & MessageFlags.ADD.value: if message.flags & MessageFlags.ADD.value:
# connect to the first session that exists # connect to the first session that exists
logging.info("request to connect to session %s", session_id) logger.info("request to connect to session %s", session_id)
# remove client from session broker and shutdown if needed # remove client from session broker and shutdown if needed
self.remove_session_handlers() self.remove_session_handlers()
@ -1780,7 +1780,7 @@ class CoreHandler(socketserver.BaseRequestHandler):
clients.append(self) clients.append(self)
# add broadcast handlers # add broadcast handlers
logging.info("adding session broadcast handlers") logger.info("adding session broadcast handlers")
self.add_session_handlers() self.add_session_handlers()
if user: if user:
@ -1790,12 +1790,10 @@ class CoreHandler(socketserver.BaseRequestHandler):
self.send_objects() self.send_objects()
elif message.flags & MessageFlags.DELETE.value: elif message.flags & MessageFlags.DELETE.value:
# shut down the specified session(s) # shut down the specified session(s)
logging.info("request to terminate session %s", session_id) logger.info("request to terminate session %s", session_id)
self.coreemu.delete_session(session_id) self.coreemu.delete_session(session_id)
else: else:
logging.warning( logger.warning("unhandled session flags for session %s", session_id)
"unhandled session flags for session %s", session_id
)
return () return ()
@ -1817,9 +1815,7 @@ class CoreHandler(socketserver.BaseRequestHandler):
try: try:
self.sendall(reply) self.sendall(reply)
except IOError: except IOError:
logging.exception( logger.exception("error sending node emulation id message: %s", node_id)
"error sending node emulation id message: %s", node_id
)
del self.node_status_request[node_id] del self.node_status_request[node_id]
@ -1845,7 +1841,7 @@ class CoreHandler(socketserver.BaseRequestHandler):
for model_name in mobility_configs: for model_name in mobility_configs:
config = mobility_configs[model_name] config = mobility_configs[model_name]
model_class = self.session.mobility.models[model_name] model_class = self.session.mobility.models[model_name]
logging.debug( logger.debug(
"mobility config: node(%s) class(%s) values(%s)", "mobility config: node(%s) class(%s) values(%s)",
node_id, node_id,
model_class, model_class,
@ -1858,7 +1854,7 @@ class CoreHandler(socketserver.BaseRequestHandler):
# send global emane config # send global emane config
config = self.session.emane.get_configs() config = self.session.emane.get_configs()
logging.debug("global emane config: values(%s)", config) logger.debug("global emane config: values(%s)", config)
config_data = ConfigShim.config_data( config_data = ConfigShim.config_data(
0, None, ConfigFlags.UPDATE.value, self.session.emane.emane_config, config 0, None, ConfigFlags.UPDATE.value, self.session.emane.emane_config, config
) )
@ -1870,7 +1866,7 @@ class CoreHandler(socketserver.BaseRequestHandler):
for model_name in emane_configs: for model_name in emane_configs:
config = emane_configs[model_name] config = emane_configs[model_name]
model_class = self.session.emane.models[model_name] model_class = self.session.emane.models[model_name]
logging.debug( logger.debug(
"emane config: node(%s) class(%s) values(%s)", "emane config: node(%s) class(%s) values(%s)",
node_id, node_id,
model_class, model_class,
@ -1951,7 +1947,7 @@ class CoreHandler(socketserver.BaseRequestHandler):
self.session.broadcast_config(config_data) self.session.broadcast_config(config_data)
node_count = self.session.get_node_count() node_count = self.session.get_node_count()
logging.info( logger.info(
"informed GUI about %d nodes and %d links", node_count, len(all_links) "informed GUI about %d nodes and %d links", node_count, len(all_links)
) )
@ -1991,11 +1987,11 @@ class CoreUdpHandler(CoreHandler):
header header
) )
if message_len == 0: if message_len == 0:
logging.warning("received message with no data") logger.warning("received message with no data")
return return
if len(data) != coreapi.CoreMessage.header_len + message_len: if len(data) != coreapi.CoreMessage.header_len + message_len:
logging.error( logger.error(
"received message length does not match received data (%s != %s)", "received message length does not match received data (%s != %s)",
len(data), len(data),
coreapi.CoreMessage.header_len + message_len, coreapi.CoreMessage.header_len + message_len,
@ -2013,7 +2009,7 @@ class CoreUdpHandler(CoreHandler):
message_flags, header, data[coreapi.CoreMessage.header_len :] message_flags, header, data[coreapi.CoreMessage.header_len :]
) )
message.msgtype = message_type message.msgtype = message_type
logging.exception("unimplemented core message type: %s", message.type_str()) logger.exception("unimplemented core message type: %s", message.type_str())
def handle(self): def handle(self):
message = self.receive_message() message = self.receive_message()
@ -2023,12 +2019,12 @@ class CoreUdpHandler(CoreHandler):
for session_id in sessions: for session_id in sessions:
session = self.server.mainserver.coreemu.sessions.get(session_id) session = self.server.mainserver.coreemu.sessions.get(session_id)
if session: if session:
logging.debug("session handling message: %s", session.id) logger.debug("session handling message: %s", session.id)
self.session = session self.session = session
self.handle_message(message) self.handle_message(message)
self.broadcast(message) self.broadcast(message)
else: else:
logging.error( logger.error(
"session %d in %s message not found.", "session %d in %s message not found.",
session_id, session_id,
message.type_str(), message.type_str(),
@ -2052,7 +2048,7 @@ class CoreUdpHandler(CoreHandler):
self.handle_message(message) self.handle_message(message)
self.broadcast(message) self.broadcast(message)
else: else:
logging.error( logger.error(
"no active session, dropping %s message.", message.type_str() "no active session, dropping %s message.", message.type_str()
) )
@ -2065,7 +2061,7 @@ class CoreUdpHandler(CoreHandler):
try: try:
client.sendall(message.raw_message) client.sendall(message.raw_message)
except IOError: except IOError:
logging.error("error broadcasting") logger.error("error broadcasting")
def finish(self): def finish(self):
return socketserver.BaseRequestHandler.finish(self) return socketserver.BaseRequestHandler.finish(self)

8
daemon/core/api/tlv/dataconversion.py
View file

@ -10,6 +10,8 @@ from core.api.tlv.enumerations import ConfigTlvs, NodeTlvs
from core.config import ConfigGroup, ConfigurableOptions from core.config import ConfigGroup, ConfigurableOptions
from core.emulator.data import ConfigData, NodeData from core.emulator.data import ConfigData, NodeData
logger = logging.getLogger(__name__)
def convert_node(node_data: NodeData): def convert_node(node_data: NodeData):
""" """
@ -139,9 +141,9 @@ class ConfigShim:
captions = None captions = None
data_types = [] data_types = []
possible_values = [] possible_values = []
logging.debug("configurable: %s", configurable_options) logger.debug("configurable: %s", configurable_options)
logging.debug("configuration options: %s", configurable_options.configurations) logger.debug("configuration options: %s", configurable_options.configurations)
logging.debug("configuration data: %s", config) logger.debug("configuration data: %s", config)
for configuration in configurable_options.configurations(): for configuration in configurable_options.configurations():
if not captions: if not captions:
captions = configuration.label captions = configuration.label

6
daemon/core/api/tlv/structutils.py
View file

@ -4,6 +4,8 @@ Utilities for working with python struct data.
import logging import logging
logger = logging.getLogger(__name__)
def pack_values(clazz, packers): def pack_values(clazz, packers):
""" """
@ -15,7 +17,7 @@ def pack_values(clazz, packers):
""" """
# iterate through tuples of values to pack # iterate through tuples of values to pack
logging.debug("packing: %s", packers) logger.debug("packing: %s", packers)
data = b"" data = b""
for packer in packers: for packer in packers:
# check if a transformer was provided for valid values # check if a transformer was provided for valid values
@ -37,7 +39,7 @@ def pack_values(clazz, packers):
value = transformer(value) value = transformer(value)
# pack and add to existing data # pack and add to existing data
logging.debug("packing: %s - %s type(%s)", tlv_type, value, type(value)) logger.debug("packing: %s - %s type(%s)", tlv_type, value, type(value))
data += clazz.pack(tlv_type.value, value) data += clazz.pack(tlv_type.value, value)
return data return data

8
daemon/core/config.py
View file

@ -12,6 +12,8 @@ from core.emulator.enumerations import ConfigDataTypes
from core.errors import CoreConfigError from core.errors import CoreConfigError
from core.nodes.network import WlanNode from core.nodes.network import WlanNode
logger = logging.getLogger(__name__)
if TYPE_CHECKING: if TYPE_CHECKING:
from core.location.mobility import WirelessModel from core.location.mobility import WirelessModel
@ -178,7 +180,7 @@ class ConfigurableManager:
:param config_type: configuration type to store configuration for :param config_type: configuration type to store configuration for
:return: nothing :return: nothing
""" """
logging.debug( logger.debug(
"setting config for node(%s) type(%s): %s", node_id, config_type, config "setting config for node(%s) type(%s): %s", node_id, config_type, config
) )
node_configs = self.node_configurations.setdefault(node_id, OrderedDict()) node_configs = self.node_configurations.setdefault(node_id, OrderedDict())
@ -310,7 +312,7 @@ class ModelManager(ConfigurableManager):
:param config: model configuration, None for default configuration :param config: model configuration, None for default configuration
:return: nothing :return: nothing
""" """
logging.debug( logger.debug(
"setting model(%s) for node(%s): %s", model_class.name, node.id, config "setting model(%s) for node(%s): %s", model_class.name, node.id, config
) )
self.set_model_config(node.id, model_class.name, config) self.set_model_config(node.id, model_class.name, config)
@ -339,5 +341,5 @@ class ModelManager(ConfigurableManager):
model_class = self.models[model_name] model_class = self.models[model_name]
models.append((model_class, config)) models.append((model_class, config))
logging.debug("models for node(%s): %s", node.id, models) logger.debug("models for node(%s): %s", node.id, models)
return models return models

9
daemon/core/configservice/base.py
View file

@ -14,6 +14,7 @@ from core.config import Configuration
from core.errors import CoreCommandError, CoreError from core.errors import CoreCommandError, CoreError
from core.nodes.base import CoreNode from core.nodes.base import CoreNode
logger = logging.getLogger(__name__)
TEMPLATES_DIR: str = "templates" TEMPLATES_DIR: str = "templates"
@ -133,7 +134,7 @@ class ConfigService(abc.ABC):
:return: nothing :return: nothing
:raises ConfigServiceBootError: when there is an error starting service :raises ConfigServiceBootError: when there is an error starting service
""" """
logging.info("node(%s) service(%s) starting...", self.node.name, self.name) logger.info("node(%s) service(%s) starting...", self.node.name, self.name)
self.create_dirs() self.create_dirs()
self.create_files() self.create_files()
wait = self.validation_mode == ConfigServiceMode.BLOCKING wait = self.validation_mode == ConfigServiceMode.BLOCKING
@ -154,7 +155,7 @@ class ConfigService(abc.ABC):
try: try:
self.node.cmd(cmd) self.node.cmd(cmd)
except CoreCommandError: except CoreCommandError:
logging.exception( logger.exception(
f"node({self.node.name}) service({self.name}) " f"node({self.node.name}) service({self.name}) "
f"failed shutdown: {cmd}" f"failed shutdown: {cmd}"
) )
@ -250,7 +251,7 @@ class ConfigService(abc.ABC):
else: else:
text = self.get_text_template(name) text = self.get_text_template(name)
rendered = self.render_text(text, data) rendered = self.render_text(text, data)
logging.debug( logger.debug(
"node(%s) service(%s) template(%s): \n%s", "node(%s) service(%s) template(%s): \n%s",
self.node.name, self.node.name,
self.name, self.name,
@ -301,7 +302,7 @@ class ConfigService(abc.ABC):
del cmds[index] del cmds[index]
index += 1 index += 1
except CoreCommandError: except CoreCommandError:
logging.debug( logger.debug(
f"node({self.node.name}) service({self.name}) " f"node({self.node.name}) service({self.name}) "
f"validate command failed: {cmd}" f"validate command failed: {cmd}"
) )

10
daemon/core/configservice/dependencies.py
View file

@ -1,6 +1,8 @@
import logging import logging
from typing import TYPE_CHECKING, Dict, List, Set from typing import TYPE_CHECKING, Dict, List, Set
logger = logging.getLogger(__name__)
if TYPE_CHECKING: if TYPE_CHECKING:
from core.configservice.base import ConfigService from core.configservice.base import ConfigService
@ -41,7 +43,7 @@ class ConfigServiceDependencies:
for name in self.node_services: for name in self.node_services:
service = self.node_services[name] service = self.node_services[name]
if service.name in self.started: if service.name in self.started:
logging.debug( logger.debug(
"skipping service that will already be started: %s", service.name "skipping service that will already be started: %s", service.name
) )
continue continue
@ -75,7 +77,7 @@ class ConfigServiceDependencies:
:param service: service to check dependencies for :param service: service to check dependencies for
:return: list of config services to start in order :return: list of config services to start in order
""" """
logging.debug("starting service dependency check: %s", service.name) logger.debug("starting service dependency check: %s", service.name)
self._reset() self._reset()
return self._visit(service) return self._visit(service)
@ -86,7 +88,7 @@ class ConfigServiceDependencies:
:param current_service: service being visited :param current_service: service being visited
:return: list of dependent services for a visited service :return: list of dependent services for a visited service
""" """
logging.debug("visiting service(%s): %s", current_service.name, self.path) logger.debug("visiting service(%s): %s", current_service.name, self.path)
self.visited.add(current_service.name) self.visited.add(current_service.name)
self.visiting.add(current_service.name) self.visiting.add(current_service.name)
@ -109,7 +111,7 @@ class ConfigServiceDependencies:
self._visit(service) self._visit(service)
# add service when bottom is found # add service when bottom is found
logging.debug("adding service to startup path: %s", current_service.name) logger.debug("adding service to startup path: %s", current_service.name)
self.started.add(current_service.name) self.started.add(current_service.name)
self.path.append(current_service) self.path.append(current_service)
self.visiting.remove(current_service.name) self.visiting.remove(current_service.name)

8
daemon/core/configservice/manager.py
View file

@ -7,6 +7,8 @@ from core import utils
from core.configservice.base import ConfigService from core.configservice.base import ConfigService
from core.errors import CoreError from core.errors import CoreError
logger = logging.getLogger(__name__)
class ConfigServiceManager: class ConfigServiceManager:
""" """
@ -41,7 +43,7 @@ class ConfigServiceManager:
:raises CoreError: when service is a duplicate or has unmet executables :raises CoreError: when service is a duplicate or has unmet executables
""" """
name = service.name name = service.name
logging.debug( logger.debug(
"loading service: class(%s) name(%s)", service.__class__.__name__, name "loading service: class(%s) name(%s)", service.__class__.__name__, name
) )
@ -71,12 +73,12 @@ class ConfigServiceManager:
subdirs.append(path) subdirs.append(path)
service_errors = [] service_errors = []
for subdir in subdirs: for subdir in subdirs:
logging.debug("loading config services from: %s", subdir) logger.debug("loading config services from: %s", subdir)
services = utils.load_classes(subdir, ConfigService) services = utils.load_classes(subdir, ConfigService)
for service in services: for service in services:
try: try:
self.add(service) self.add(service)
except CoreError as e: except CoreError as e:
service_errors.append(service.name) service_errors.append(service.name)
logging.debug("not loading service(%s): %s", service.name, e) logger.debug("not loading service(%s): %s", service.name, e)
return service_errors return service_errors

3
daemon/core/configservices/quaggaservices/services.py
View file

@ -9,6 +9,7 @@ from core.nodes.base import CoreNodeBase
from core.nodes.interface import DEFAULT_MTU, CoreInterface from core.nodes.interface import DEFAULT_MTU, CoreInterface
from core.nodes.network import WlanNode from core.nodes.network import WlanNode
logger = logging.getLogger(__name__)
GROUP: str = "Quagga" GROUP: str = "Quagga"
QUAGGA_STATE_DIR: str = "/var/run/quagga" QUAGGA_STATE_DIR: str = "/var/run/quagga"
@ -229,7 +230,7 @@ class Ospfv3mdr(Ospfv3):
def data(self) -> Dict[str, Any]: def data(self) -> Dict[str, Any]:
for iface in self.node.get_ifaces(): for iface in self.node.get_ifaces():
is_wireless = isinstance(iface.net, (WlanNode, EmaneNet)) is_wireless = isinstance(iface.net, (WlanNode, EmaneNet))
logging.info("MDR wireless: %s", is_wireless) logger.info("MDR wireless: %s", is_wireless)
return dict() return dict()
def quagga_iface_config(self, iface: CoreInterface) -> str: def quagga_iface_config(self, iface: CoreInterface) -> str:

10
daemon/core/emane/commeffect.py
View file

@ -14,6 +14,8 @@ from core.emulator.data import LinkOptions
from core.nodes.interface import CoreInterface from core.nodes.interface import CoreInterface
from core.xml import emanexml from core.xml import emanexml
logger = logging.getLogger(__name__)
try: try:
from emane.events.commeffectevent import CommEffectEvent from emane.events.commeffectevent import CommEffectEvent
except ImportError: except ImportError:
@ -21,7 +23,7 @@ except ImportError:
from emanesh.events.commeffectevent import CommEffectEvent from emanesh.events.commeffectevent import CommEffectEvent
except ImportError: except ImportError:
CommEffectEvent = None CommEffectEvent = None
logging.debug("compatible emane python bindings not installed") logger.debug("compatible emane python bindings not installed")
def convert_none(x: float) -> int: def convert_none(x: float) -> int:
@ -113,11 +115,11 @@ class EmaneCommEffectModel(emanemodel.EmaneModel):
""" """
service = self.session.emane.service service = self.session.emane.service
if service is None: if service is None:
logging.warning("%s: EMANE event service unavailable", self.name) logger.warning("%s: EMANE event service unavailable", self.name)
return return
if iface is None or iface2 is None: if iface is None or iface2 is None:
logging.warning("%s: missing NEM information", self.name) logger.warning("%s: missing NEM information", self.name)
return return
# TODO: batch these into multiple events per transmission # TODO: batch these into multiple events per transmission
@ -125,7 +127,7 @@ class EmaneCommEffectModel(emanemodel.EmaneModel):
event = CommEffectEvent() event = CommEffectEvent()
nem1 = self.session.emane.get_nem_id(iface) nem1 = self.session.emane.get_nem_id(iface)
nem2 = self.session.emane.get_nem_id(iface2) nem2 = self.session.emane.get_nem_id(iface2)
logging.info("sending comm effect event") logger.info("sending comm effect event")
event.append( event.append(
nem1, nem1,
latency=convert_none(options.delay), latency=convert_none(options.delay),

92
daemon/core/emane/emanemanager.py
View file

@ -34,6 +34,8 @@ from core.nodes.base import CoreNetworkBase, CoreNode, CoreNodeBase, NodeBase
from core.nodes.interface import CoreInterface, TunTap from core.nodes.interface import CoreInterface, TunTap
from core.xml import emanexml from core.xml import emanexml
logger = logging.getLogger(__name__)
if TYPE_CHECKING: if TYPE_CHECKING:
from core.emulator.session import Session from core.emulator.session import Session
@ -51,7 +53,7 @@ except ImportError:
LocationEvent = None LocationEvent = None
PathlossEvent = None PathlossEvent = None
EventServiceException = None EventServiceException = None
logging.debug("compatible emane python bindings not installed") logger.debug("compatible emane python bindings not installed")
EMANE_MODELS = [ EMANE_MODELS = [
EmaneRfPipeModel, EmaneRfPipeModel,
@ -174,11 +176,11 @@ class EmaneManager(ModelManager):
# check for emane # check for emane
path = utils.which("emane", required=False) path = utils.which("emane", required=False)
if not path: if not path:
logging.info("emane is not installed") logger.info("emane is not installed")
return return
# get version # get version
emane_version = utils.cmd("emane --version") emane_version = utils.cmd("emane --version")
logging.info("using emane: %s", emane_version) logger.info("using emane: %s", emane_version)
# load default emane models # load default emane models
self.load_models(EMANE_MODELS) self.load_models(EMANE_MODELS)
# load custom models # load custom models
@ -214,7 +216,7 @@ class EmaneManager(ModelManager):
self.event_device = self.get_config("eventservicedevice") self.event_device = self.get_config("eventservicedevice")
eventnetidx = self.session.get_control_net_index(self.event_device) eventnetidx = self.session.get_control_net_index(self.event_device)
if eventnetidx < 0: if eventnetidx < 0:
logging.error( logger.error(
"invalid emane event service device provided: %s", self.event_device "invalid emane event service device provided: %s", self.event_device
) )
return return
@ -230,18 +232,18 @@ class EmaneManager(ModelManager):
# disabled otachannel for event service # disabled otachannel for event service
# only needed for e.g. antennaprofile events xmit by models # only needed for e.g. antennaprofile events xmit by models
logging.info("using %s for event service traffic", self.event_device) logger.info("using %s for event service traffic", self.event_device)
try: try:
self.service = EventService(eventchannel=self.eventchannel, otachannel=None) self.service = EventService(eventchannel=self.eventchannel, otachannel=None)
except EventServiceException: except EventServiceException:
logging.exception("error instantiating emane EventService") logger.exception("error instantiating emane EventService")
def load_models(self, emane_models: List[Type[EmaneModel]]) -> None: def load_models(self, emane_models: List[Type[EmaneModel]]) -> None:
""" """
Load EMANE models and make them available. Load EMANE models and make them available.
""" """
for emane_model in emane_models: for emane_model in emane_models:
logging.debug("loading emane model: %s", emane_model.__name__) logger.debug("loading emane model: %s", emane_model.__name__)
emane_prefix = self.session.options.get_config( emane_prefix = self.session.options.get_config(
"emane_prefix", default=DEFAULT_EMANE_PREFIX "emane_prefix", default=DEFAULT_EMANE_PREFIX
) )
@ -281,17 +283,17 @@ class EmaneManager(ModelManager):
:return: SUCCESS, NOT_NEEDED, NOT_READY in order to delay session :return: SUCCESS, NOT_NEEDED, NOT_READY in order to delay session
instantiation instantiation
""" """
logging.debug("emane setup") logger.debug("emane setup")
with self.session.nodes_lock: with self.session.nodes_lock:
for node_id in self.session.nodes: for node_id in self.session.nodes:
node = self.session.nodes[node_id] node = self.session.nodes[node_id]
if isinstance(node, EmaneNet): if isinstance(node, EmaneNet):
logging.debug( logger.debug(
"adding emane node: id(%s) name(%s)", node.id, node.name "adding emane node: id(%s) name(%s)", node.id, node.name
) )
self.add_node(node) self.add_node(node)
if not self._emane_nets: if not self._emane_nets:
logging.debug("no emane nodes in session") logger.debug("no emane nodes in session")
return EmaneState.NOT_NEEDED return EmaneState.NOT_NEEDED
# check if bindings were installed # check if bindings were installed
@ -302,9 +304,9 @@ class EmaneManager(ModelManager):
# - needs to exist when eventservice binds to it (initeventservice) # - needs to exist when eventservice binds to it (initeventservice)
otadev = self.get_config("otamanagerdevice") otadev = self.get_config("otamanagerdevice")
netidx = self.session.get_control_net_index(otadev) netidx = self.session.get_control_net_index(otadev)
logging.debug("emane ota manager device: index(%s) otadev(%s)", netidx, otadev) logger.debug("emane ota manager device: index(%s) otadev(%s)", netidx, otadev)
if netidx < 0: if netidx < 0:
logging.error( logger.error(
"EMANE cannot start, check core config. invalid OTA device provided: %s", "EMANE cannot start, check core config. invalid OTA device provided: %s",
otadev, otadev,
) )
@ -314,12 +316,12 @@ class EmaneManager(ModelManager):
net_index=netidx, remove=False, conf_required=False net_index=netidx, remove=False, conf_required=False
) )
eventdev = self.get_config("eventservicedevice") eventdev = self.get_config("eventservicedevice")
logging.debug("emane event service device: eventdev(%s)", eventdev) logger.debug("emane event service device: eventdev(%s)", eventdev)
if eventdev != otadev: if eventdev != otadev:
netidx = self.session.get_control_net_index(eventdev) netidx = self.session.get_control_net_index(eventdev)
logging.debug("emane event service device index: %s", netidx) logger.debug("emane event service device index: %s", netidx)
if netidx < 0: if netidx < 0:
logging.error( logger.error(
"emane cannot start due to invalid event service device: %s", "emane cannot start due to invalid event service device: %s",
eventdev, eventdev,
) )
@ -346,7 +348,7 @@ class EmaneManager(ModelManager):
self.starteventmonitor() self.starteventmonitor()
self.buildeventservicexml() self.buildeventservicexml()
with self._emane_node_lock: with self._emane_node_lock:
logging.info("emane building xmls...") logger.info("emane building xmls...")
start_data = self.get_start_data() start_data = self.get_start_data()
for data in start_data: for data in start_data:
self.start_node(data) self.start_node(data)
@ -359,11 +361,11 @@ class EmaneManager(ModelManager):
for node_id in sorted(self._emane_nets): for node_id in sorted(self._emane_nets):
emane_net = self._emane_nets[node_id] emane_net = self._emane_nets[node_id]
if not emane_net.model: if not emane_net.model:
logging.error("emane net(%s) has no model", emane_net.name) logger.error("emane net(%s) has no model", emane_net.name)
continue continue
for iface in emane_net.get_ifaces(): for iface in emane_net.get_ifaces():
if not iface.node: if not iface.node:
logging.error( logger.error(
"emane net(%s) connected interface(%s) missing node", "emane net(%s) connected interface(%s) missing node",
emane_net.name, emane_net.name,
iface.name, iface.name,
@ -403,7 +405,7 @@ class EmaneManager(ModelManager):
with path.open("a") as f: with path.open("a") as f:
f.write(f"{iface.node.name} {iface.name} {nem_id}\n") f.write(f"{iface.node.name} {iface.name} {nem_id}\n")
except IOError: except IOError:
logging.exception("error writing to emane nem file") logger.exception("error writing to emane nem file")
def links_enabled(self) -> bool: def links_enabled(self) -> bool:
return self.get_config("link_enabled") == "1" return self.get_config("link_enabled") == "1"
@ -417,7 +419,7 @@ class EmaneManager(ModelManager):
with self._emane_node_lock: with self._emane_node_lock:
for node_id in sorted(self._emane_nets): for node_id in sorted(self._emane_nets):
emane_net = self._emane_nets[node_id] emane_net = self._emane_nets[node_id]
logging.debug( logger.debug(
"post startup for emane node: %s - %s", emane_net.id, emane_net.name "post startup for emane node: %s - %s", emane_net.id, emane_net.name
) )
emane_net.model.post_startup() emane_net.model.post_startup()
@ -441,7 +443,7 @@ class EmaneManager(ModelManager):
with self._emane_node_lock: with self._emane_node_lock:
if not self._emane_nets: if not self._emane_nets:
return return
logging.info("stopping EMANE daemons") logger.info("stopping EMANE daemons")
if self.links_enabled(): if self.links_enabled():
self.link_monitor.stop() self.link_monitor.stop()
# shutdown interfaces and stop daemons # shutdown interfaces and stop daemons
@ -467,11 +469,11 @@ class EmaneManager(ModelManager):
""" """
for node_id in self._emane_nets: for node_id in self._emane_nets:
emane_net = self._emane_nets[node_id] emane_net = self._emane_nets[node_id]
logging.debug("checking emane model for node: %s", node_id) logger.debug("checking emane model for node: %s", node_id)
# skip nodes that already have a model set # skip nodes that already have a model set
if emane_net.model: if emane_net.model:
logging.debug( logger.debug(
"node(%s) already has model(%s)", emane_net.id, emane_net.model.name "node(%s) already has model(%s)", emane_net.id, emane_net.model.name
) )
continue continue
@ -480,11 +482,11 @@ class EmaneManager(ModelManager):
# before nodes exist # before nodes exist
model_name = self.node_models.get(node_id) model_name = self.node_models.get(node_id)
if not model_name: if not model_name:
logging.error("emane node(%s) has no node model", node_id) logger.error("emane node(%s) has no node model", node_id)
raise ValueError("emane node has no model set") raise ValueError("emane node has no model set")
config = self.get_model_config(node_id=node_id, model_name=model_name) config = self.get_model_config(node_id=node_id, model_name=model_name)
logging.debug("setting emane model(%s) config(%s)", model_name, config) logger.debug("setting emane model(%s) config(%s)", model_name, config)
model_class = self.models[model_name] model_class = self.models[model_name]
emane_net.setmodel(model_class, config) emane_net.setmodel(model_class, config)
@ -493,12 +495,12 @@ class EmaneManager(ModelManager):
) -> Optional[LinkData]: ) -> Optional[LinkData]:
iface1 = self.get_iface(nem1) iface1 = self.get_iface(nem1)
if not iface1: if not iface1:
logging.error("invalid nem: %s", nem1) logger.error("invalid nem: %s", nem1)
return None return None
node1 = iface1.node node1 = iface1.node
iface2 = self.get_iface(nem2) iface2 = self.get_iface(nem2)
if not iface2: if not iface2:
logging.error("invalid nem: %s", nem2) logger.error("invalid nem: %s", nem2)
return None return None
node2 = iface2.node node2 = iface2.node
if iface1.net != iface2.net: if iface1.net != iface2.net:
@ -535,7 +537,7 @@ class EmaneManager(ModelManager):
try: try:
group, port = self.get_config("eventservicegroup").split(":") group, port = self.get_config("eventservicegroup").split(":")
except ValueError: except ValueError:
logging.exception("invalid eventservicegroup in EMANE config") logger.exception("invalid eventservicegroup in EMANE config")
return return
dev = self.get_config("eventservicedevice") dev = self.get_config("eventservicedevice")
@ -551,12 +553,12 @@ class EmaneManager(ModelManager):
Start one EMANE daemon per node having a radio. Start one EMANE daemon per node having a radio.
Add a control network even if the user has not configured one. Add a control network even if the user has not configured one.
""" """
logging.info("starting emane daemons...") logger.info("starting emane daemons...")
loglevel = str(EmaneManager.DEFAULT_LOG_LEVEL) loglevel = str(EmaneManager.DEFAULT_LOG_LEVEL)
cfgloglevel = self.session.options.get_config_int("emane_log_level") cfgloglevel = self.session.options.get_config_int("emane_log_level")
realtime = self.session.options.get_config_bool("emane_realtime", default=True) realtime = self.session.options.get_config_bool("emane_realtime", default=True)
if cfgloglevel: if cfgloglevel:
logging.info("setting user-defined emane log level: %d", cfgloglevel) logger.info("setting user-defined emane log level: %d", cfgloglevel)
loglevel = str(cfgloglevel) loglevel = str(cfgloglevel)
emanecmd = f"emane -d -l {loglevel}" emanecmd = f"emane -d -l {loglevel}"
if realtime: if realtime:
@ -574,17 +576,17 @@ class EmaneManager(ModelManager):
node, 0, remove=False, conf_required=False node, 0, remove=False, conf_required=False
) )
if otanetidx > 0: if otanetidx > 0:
logging.info("adding ota device ctrl%d", otanetidx) logger.info("adding ota device ctrl%d", otanetidx)
self.session.add_remove_control_iface( self.session.add_remove_control_iface(
node, otanetidx, remove=False, conf_required=False node, otanetidx, remove=False, conf_required=False
) )
if eventservicenetidx >= 0: if eventservicenetidx >= 0:
logging.info("adding event service device ctrl%d", eventservicenetidx) logger.info("adding event service device ctrl%d", eventservicenetidx)
self.session.add_remove_control_iface( self.session.add_remove_control_iface(
node, eventservicenetidx, remove=False, conf_required=False node, eventservicenetidx, remove=False, conf_required=False
) )
# multicast route is needed for OTA data # multicast route is needed for OTA data
logging.info("OTA GROUP(%s) OTA DEV(%s)", otagroup, otadev) logger.info("OTA GROUP(%s) OTA DEV(%s)", otagroup, otadev)
node.node_net_client.create_route(otagroup, otadev) node.node_net_client.create_route(otagroup, otadev)
# multicast route is also needed for event data if on control network # multicast route is also needed for event data if on control network
if eventservicenetidx >= 0 and eventgroup != otagroup: if eventservicenetidx >= 0 and eventgroup != otagroup:
@ -594,13 +596,13 @@ class EmaneManager(ModelManager):
platform_xml = node.directory / f"{node.name}-platform.xml" platform_xml = node.directory / f"{node.name}-platform.xml"
args = f"{emanecmd} -f {log_file} {platform_xml}" args = f"{emanecmd} -f {log_file} {platform_xml}"
node.cmd(args) node.cmd(args)
logging.info("node(%s) emane daemon running: %s", node.name, args) logger.info("node(%s) emane daemon running: %s", node.name, args)
else: else:
log_file = self.session.directory / f"{node.name}-emane.log" log_file = self.session.directory / f"{node.name}-emane.log"
platform_xml = self.session.directory / f"{node.name}-platform.xml" platform_xml = self.session.directory / f"{node.name}-platform.xml"
args = f"{emanecmd} -f {log_file} {platform_xml}" args = f"{emanecmd} -f {log_file} {platform_xml}"
node.host_cmd(args, cwd=self.session.directory) node.host_cmd(args, cwd=self.session.directory)
logging.info("node(%s) host emane daemon running: %s", node.name, args) logger.info("node(%s) host emane daemon running: %s", node.name, args)
def install_iface(self, iface: CoreInterface) -> None: def install_iface(self, iface: CoreInterface) -> None:
emane_net = iface.net emane_net = iface.net
@ -641,11 +643,11 @@ class EmaneManager(ModelManager):
""" """
Start monitoring EMANE location events if configured to do so. Start monitoring EMANE location events if configured to do so.
""" """
logging.info("emane start event monitor") logger.info("emane start event monitor")
if not self.doeventmonitor(): if not self.doeventmonitor():
return return
if self.service is None: if self.service is None:
logging.error( logger.error(
"Warning: EMANE events will not be generated " "Warning: EMANE events will not be generated "
"because the emaneeventservice\n binding was " "because the emaneeventservice\n binding was "
"unable to load " "unable to load "
@ -678,7 +680,7 @@ class EmaneManager(ModelManager):
""" """
if self.service is None: if self.service is None:
return return
logging.info( logger.info(
"subscribing to EMANE location events. (%s)", "subscribing to EMANE location events. (%s)",
threading.currentThread().getName(), threading.currentThread().getName(),
) )
@ -694,7 +696,7 @@ class EmaneManager(ModelManager):
if eid == LocationEvent.IDENTIFIER: if eid == LocationEvent.IDENTIFIER:
self.handlelocationevent(nem, eid, data) self.handlelocationevent(nem, eid, data)
logging.info( logger.info(
"unsubscribing from EMANE location events. (%s)", "unsubscribing from EMANE location events. (%s)",
threading.currentThread().getName(), threading.currentThread().getName(),
) )
@ -712,14 +714,14 @@ class EmaneManager(ModelManager):
or "longitude" not in attrs or "longitude" not in attrs
or "altitude" not in attrs or "altitude" not in attrs
): ):
logging.warning("dropped invalid location event") logger.warning("dropped invalid location event")
continue continue
# yaw,pitch,roll,azimuth,elevation,velocity are unhandled # yaw,pitch,roll,azimuth,elevation,velocity are unhandled
lat = attrs["latitude"] lat = attrs["latitude"]
lon = attrs["longitude"] lon = attrs["longitude"]
alt = attrs["altitude"] alt = attrs["altitude"]
logging.debug("emane location event: %s,%s,%s", lat, lon, alt) logger.debug("emane location event: %s,%s,%s", lat, lon, alt)
self.handlelocationeventtoxyz(txnemid, lat, lon, alt) self.handlelocationeventtoxyz(txnemid, lat, lon, alt)
def handlelocationeventtoxyz( def handlelocationeventtoxyz(
@ -733,7 +735,7 @@ class EmaneManager(ModelManager):
# convert nemid to node number # convert nemid to node number
iface = self.get_iface(nemid) iface = self.get_iface(nemid)
if iface is None: if iface is None:
logging.info("location event for unknown NEM %s", nemid) logger.info("location event for unknown NEM %s", nemid)
return False return False
n = iface.node.id n = iface.node.id
@ -742,7 +744,7 @@ class EmaneManager(ModelManager):
x = int(x) x = int(x)
y = int(y) y = int(y)
z = int(z) z = int(z)
logging.debug( logger.debug(
"location event NEM %s (%s, %s, %s) -> (%s, %s, %s)", "location event NEM %s (%s, %s, %s) -> (%s, %s, %s)",
nemid, nemid,
lat, lat,
@ -756,7 +758,7 @@ class EmaneManager(ModelManager):
ybit_check = y.bit_length() > 16 or y < 0 ybit_check = y.bit_length() > 16 or y < 0
zbit_check = z.bit_length() > 16 or z < 0 zbit_check = z.bit_length() > 16 or z < 0
if any([xbit_check, ybit_check, zbit_check]): if any([xbit_check, ybit_check, zbit_check]):
logging.error( logger.error(
"Unable to build node location message, received lat/long/alt " "Unable to build node location message, received lat/long/alt "
"exceeds coordinate space: NEM %s (%d, %d, %d)", "exceeds coordinate space: NEM %s (%d, %d, %d)",
nemid, nemid,
@ -770,7 +772,7 @@ class EmaneManager(ModelManager):
try: try:
node = self.session.get_node(n, NodeBase) node = self.session.get_node(n, NodeBase)
except CoreError: except CoreError:
logging.exception( logger.exception(
"location event NEM %s has no corresponding node %s", nemid, n "location event NEM %s has no corresponding node %s", nemid, n
) )
return False return False

4
daemon/core/emane/emanemanifest.py
View file

@ -5,6 +5,8 @@ from typing import Dict, List
from core.config import Configuration from core.config import Configuration
from core.emulator.enumerations import ConfigDataTypes from core.emulator.enumerations import ConfigDataTypes
logger = logging.getLogger(__name__)
manifest = None manifest = None
try: try:
from emane.shell import manifest from emane.shell import manifest
@ -13,7 +15,7 @@ except ImportError:
from emanesh import manifest from emanesh import manifest
except ImportError: except ImportError:
manifest = None manifest = None
logging.debug("compatible emane python bindings not installed") logger.debug("compatible emane python bindings not installed")
def _type_value(config_type: str) -> ConfigDataTypes: def _type_value(config_type: str) -> ConfigDataTypes:

8
daemon/core/emane/emanemodel.py
View file

@ -15,6 +15,8 @@ from core.location.mobility import WirelessModel
from core.nodes.interface import CoreInterface from core.nodes.interface import CoreInterface
from core.xml import emanexml from core.xml import emanexml
logger = logging.getLogger(__name__)
class EmaneModel(WirelessModel): class EmaneModel(WirelessModel):
""" """
@ -115,7 +117,7 @@ class EmaneModel(WirelessModel):
:return: nothing :return: nothing
""" """
logging.debug("emane model(%s) has no post setup tasks", self.name) logger.debug("emane model(%s) has no post setup tasks", self.name)
def update(self, moved_ifaces: List[CoreInterface]) -> None: def update(self, moved_ifaces: List[CoreInterface]) -> None:
""" """
@ -130,7 +132,7 @@ class EmaneModel(WirelessModel):
emane_net = self.session.get_node(self.id, EmaneNet) emane_net = self.session.get_node(self.id, EmaneNet)
emane_net.setnempositions(moved_ifaces) emane_net.setnempositions(moved_ifaces)
except CoreError: except CoreError:
logging.exception("error during update") logger.exception("error during update")
def linkconfig( def linkconfig(
self, iface: CoreInterface, options: LinkOptions, iface2: CoreInterface = None self, iface: CoreInterface, options: LinkOptions, iface2: CoreInterface = None
@ -143,4 +145,4 @@ class EmaneModel(WirelessModel):
:param iface2: interface two :param iface2: interface two
:return: nothing :return: nothing
""" """
logging.warning("emane model(%s) does not support link config", self.name) logger.warning("emane model(%s) does not support link config", self.name)

20
daemon/core/emane/linkmonitor.py
View file

@ -10,6 +10,8 @@ from core.emulator.data import LinkData
from core.emulator.enumerations import LinkTypes, MessageFlags from core.emulator.enumerations import LinkTypes, MessageFlags
from core.nodes.network import CtrlNet from core.nodes.network import CtrlNet
logger = logging.getLogger(__name__)
try: try:
from emane import shell from emane import shell
except ImportError: except ImportError:
@ -17,7 +19,7 @@ except ImportError:
from emanesh import shell from emanesh import shell
except ImportError: except ImportError:
shell = None shell = None
logging.debug("compatible emane python bindings not installed") logger.debug("compatible emane python bindings not installed")
if TYPE_CHECKING: if TYPE_CHECKING:
from core.emane.emanemanager import EmaneManager from core.emane.emanemanager import EmaneManager
@ -91,7 +93,7 @@ class EmaneClient:
# get mac config # get mac config
mac_id, _, emane_model = components[MAC_COMPONENT_INDEX] mac_id, _, emane_model = components[MAC_COMPONENT_INDEX]
mac_config = self.client.getConfiguration(mac_id) mac_config = self.client.getConfiguration(mac_id)
logging.debug( logger.debug(
"address(%s) nem(%s) emane(%s)", self.address, nem_id, emane_model "address(%s) nem(%s) emane(%s)", self.address, nem_id, emane_model
) )
@ -101,9 +103,9 @@ class EmaneClient:
elif emane_model == EMANE_RFPIPE: elif emane_model == EMANE_RFPIPE:
loss_table = self.handle_rfpipe(mac_config) loss_table = self.handle_rfpipe(mac_config)
else: else:
logging.warning("unknown emane link model: %s", emane_model) logger.warning("unknown emane link model: %s", emane_model)
continue continue
logging.info("monitoring links nem(%s) model(%s)", nem_id, emane_model) logger.info("monitoring links nem(%s) model(%s)", nem_id, emane_model)
loss_table.mac_id = mac_id loss_table.mac_id = mac_id
self.nems[nem_id] = loss_table self.nems[nem_id] = loss_table
@ -138,12 +140,12 @@ class EmaneClient:
def handle_tdma(self, config: Dict[str, Tuple]): def handle_tdma(self, config: Dict[str, Tuple]):
pcr = config["pcrcurveuri"][0][0] pcr = config["pcrcurveuri"][0][0]
logging.debug("tdma pcr: %s", pcr) logger.debug("tdma pcr: %s", pcr)
def handle_80211(self, config: Dict[str, Tuple]) -> LossTable: def handle_80211(self, config: Dict[str, Tuple]) -> LossTable:
unicastrate = config["unicastrate"][0][0] unicastrate = config["unicastrate"][0][0]
pcr = config["pcrcurveuri"][0][0] pcr = config["pcrcurveuri"][0][0]
logging.debug("80211 pcr: %s", pcr) logger.debug("80211 pcr: %s", pcr)
tree = etree.parse(pcr) tree = etree.parse(pcr)
root = tree.getroot() root = tree.getroot()
table = root.find("table") table = root.find("table")
@ -159,7 +161,7 @@ class EmaneClient:
def handle_rfpipe(self, config: Dict[str, Tuple]) -> LossTable: def handle_rfpipe(self, config: Dict[str, Tuple]) -> LossTable:
pcr = config["pcrcurveuri"][0][0] pcr = config["pcrcurveuri"][0][0]
logging.debug("rfpipe pcr: %s", pcr) logger.debug("rfpipe pcr: %s", pcr)
tree = etree.parse(pcr) tree = etree.parse(pcr)
root = tree.getroot() root = tree.getroot()
table = root.find("table") table = root.find("table")
@ -192,7 +194,7 @@ class EmaneLinkMonitor:
self.link_timeout = int(self.emane_manager.get_config("link_timeout")) self.link_timeout = int(self.emane_manager.get_config("link_timeout"))
self.initialize() self.initialize()
if not self.clients: if not self.clients:
logging.info("no valid emane models to monitor links") logger.info("no valid emane models to monitor links")
return return
self.scheduler = sched.scheduler() self.scheduler = sched.scheduler()
self.scheduler.enter(0, 0, self.check_links) self.scheduler.enter(0, 0, self.check_links)
@ -228,7 +230,7 @@ class EmaneLinkMonitor:
client.check_links(self.links, self.loss_threshold) client.check_links(self.links, self.loss_threshold)
except shell.ControlPortException: except shell.ControlPortException:
if self.running: if self.running:
logging.exception("link monitor error") logger.exception("link monitor error")
# find new links # find new links
current_links = set(self.links.keys()) current_links = set(self.links.keys())

14
daemon/core/emane/nodes.py
View file

@ -19,6 +19,8 @@ from core.errors import CoreError
from core.nodes.base import CoreNetworkBase, CoreNode from core.nodes.base import CoreNetworkBase, CoreNode
from core.nodes.interface import CoreInterface from core.nodes.interface import CoreInterface
logger = logging.getLogger(__name__)
if TYPE_CHECKING: if TYPE_CHECKING:
from core.emane.emanemodel import EmaneModel from core.emane.emanemodel import EmaneModel
from core.emulator.session import Session from core.emulator.session import Session
@ -34,7 +36,7 @@ except ImportError:
from emanesh.events import LocationEvent from emanesh.events import LocationEvent
except ImportError: except ImportError:
LocationEvent = None LocationEvent = None
logging.debug("compatible emane python bindings not installed") logger.debug("compatible emane python bindings not installed")
class EmaneNet(CoreNetworkBase): class EmaneNet(CoreNetworkBase):
@ -92,9 +94,7 @@ class EmaneNet(CoreNetworkBase):
def updatemodel(self, config: Dict[str, str]) -> None: def updatemodel(self, config: Dict[str, str]) -> None:
if not self.model: if not self.model:
raise CoreError(f"no model set to update for node({self.name})") raise CoreError(f"no model set to update for node({self.name})")
logging.info( logger.info("node(%s) updating model(%s): %s", self.id, self.model.name, config)
"node(%s) updating model(%s): %s", self.id, self.model.name, config
)
self.model.update_config(config) self.model.update_config(config)
def setmodel(self, model: "WirelessModelType", config: Dict[str, str]) -> None: def setmodel(self, model: "WirelessModelType", config: Dict[str, str]) -> None:
@ -122,7 +122,7 @@ class EmaneNet(CoreNetworkBase):
nem_id = self.session.emane.get_nem_id(iface) nem_id = self.session.emane.get_nem_id(iface)
ifname = iface.localname ifname = iface.localname
if nem_id is None: if nem_id is None:
logging.info("nemid for %s is unknown", ifname) logger.info("nemid for %s is unknown", ifname)
return return
node = iface.node node = iface.node
x, y, z = node.getposition() x, y, z = node.getposition()
@ -141,7 +141,7 @@ class EmaneNet(CoreNetworkBase):
:param iface: interface to set nem position for :param iface: interface to set nem position for
""" """
if self.session.emane.service is None: if self.session.emane.service is None:
logging.info("position service not available") logger.info("position service not available")
return return
position = self._nem_position(iface) position = self._nem_position(iface)
if position: if position:
@ -160,7 +160,7 @@ class EmaneNet(CoreNetworkBase):
return return
if self.session.emane.service is None: if self.session.emane.service is None:
logging.info("position service not available") logger.info("position service not available")
return return
event = LocationEvent() event = LocationEvent()

4
daemon/core/emane/tdma.py
View file

@ -11,6 +11,8 @@ from core.config import Configuration
from core.emane import emanemodel from core.emane import emanemodel
from core.emulator.enumerations import ConfigDataTypes from core.emulator.enumerations import ConfigDataTypes
logger = logging.getLogger(__name__)
class EmaneTdmaModel(emanemodel.EmaneModel): class EmaneTdmaModel(emanemodel.EmaneModel):
# model name # model name
@ -58,7 +60,7 @@ class EmaneTdmaModel(emanemodel.EmaneModel):
event_device = self.session.emane.event_device event_device = self.session.emane.event_device
# initiate tdma schedule # initiate tdma schedule
logging.info( logger.info(
"setting up tdma schedule: schedule(%s) device(%s)", schedule, event_device "setting up tdma schedule: schedule(%s) device(%s)", schedule, event_device
) )
args = f"emaneevent-tdmaschedule -i {event_device} {schedule}" args = f"emaneevent-tdmaschedule -i {event_device} {schedule}"

16
daemon/core/emulator/coreemu.py
View file

@ -13,6 +13,8 @@ from core.emulator.session import Session
from core.executables import get_requirements from core.executables import get_requirements
from core.services.coreservices import ServiceManager from core.services.coreservices import ServiceManager
logger = logging.getLogger(__name__)
def signal_handler(signal_number: int, _) -> None: def signal_handler(signal_number: int, _) -> None:
""" """
@ -22,7 +24,7 @@ def signal_handler(signal_number: int, _) -> None:
:param _: ignored :param _: ignored
:return: nothing :return: nothing
""" """
logging.info("caught signal: %s", signal_number) logger.info("caught signal: %s", signal_number)
sys.exit(signal_number) sys.exit(signal_number)
@ -95,7 +97,7 @@ class CoreEmu:
self.service_errors = core.services.load() self.service_errors = core.services.load()
# load custom services # load custom services
service_paths = self.config.get("custom_services_dir") service_paths = self.config.get("custom_services_dir")
logging.debug("custom service paths: %s", service_paths) logger.debug("custom service paths: %s", service_paths)
if service_paths is not None: if service_paths is not None:
for service_path in service_paths.split(","): for service_path in service_paths.split(","):
service_path = Path(service_path.strip()) service_path = Path(service_path.strip())
@ -108,7 +110,7 @@ class CoreEmu:
:return: nothing :return: nothing
""" """
logging.info("shutting down all sessions") logger.info("shutting down all sessions")
sessions = self.sessions.copy() sessions = self.sessions.copy()
self.sessions.clear() self.sessions.clear()
for _id in sessions: for _id in sessions:
@ -129,7 +131,7 @@ class CoreEmu:
_id += 1 _id += 1
session = _cls(_id, config=self.config) session = _cls(_id, config=self.config)
session.service_manager = self.service_manager session.service_manager = self.service_manager
logging.info("created session: %s", _id) logger.info("created session: %s", _id)
self.sessions[_id] = session self.sessions[_id] = session
return session return session
@ -140,14 +142,14 @@ class CoreEmu:
:param _id: session id to delete :param _id: session id to delete
:return: True if deleted, False otherwise :return: True if deleted, False otherwise
""" """
logging.info("deleting session: %s", _id) logger.info("deleting session: %s", _id)
session = self.sessions.pop(_id, None) session = self.sessions.pop(_id, None)
result = False result = False
if session: if session:
logging.info("shutting session down: %s", _id) logger.info("shutting session down: %s", _id)
session.data_collect() session.data_collect()
session.shutdown() session.shutdown()
result = True result = True
else: else:
logging.error("session to delete did not exist: %s", _id) logger.error("session to delete did not exist: %s", _id)
return result return result

12
daemon/core/emulator/distributed.py
View file

@ -20,6 +20,8 @@ from core.executables import get_requirements
from core.nodes.interface import GreTap from core.nodes.interface import GreTap
from core.nodes.network import CoreNetwork, CtrlNet from core.nodes.network import CoreNetwork, CtrlNet
logger = logging.getLogger(__name__)
if TYPE_CHECKING: if TYPE_CHECKING:
from core.emulator.session import Session from core.emulator.session import Session
@ -62,7 +64,7 @@ class DistributedServer:
replace_env = env is not None replace_env = env is not None
if not wait: if not wait:
cmd += " &" cmd += " &"
logging.debug( logger.debug(
"remote cmd server(%s) cwd(%s) wait(%s): %s", self.host, cwd, wait, cmd "remote cmd server(%s) cwd(%s) wait(%s): %s", self.host, cwd, wait, cmd
) )
try: try:
@ -212,13 +214,11 @@ class DistributedController:
if tunnel is not None: if tunnel is not None:
return tunnel return tunnel
# local to server # local to server
logging.info( logger.info("local tunnel node(%s) to remote(%s) key(%s)", node.name, host, key)
"local tunnel node(%s) to remote(%s) key(%s)", node.name, host, key
)
local_tap = GreTap(session=self.session, remoteip=host, key=key) local_tap = GreTap(session=self.session, remoteip=host, key=key)
local_tap.net_client.set_iface_master(node.brname, local_tap.localname) local_tap.net_client.set_iface_master(node.brname, local_tap.localname)
# server to local # server to local
logging.info( logger.info(
"remote tunnel node(%s) to local(%s) key(%s)", node.name, self.address, key "remote tunnel node(%s) to local(%s) key(%s)", node.name, self.address, key
) )
remote_tap = GreTap( remote_tap = GreTap(
@ -240,7 +240,7 @@ class DistributedController:
:param node2_id: node two id :param node2_id: node two id
:return: tunnel key for the node pair :return: tunnel key for the node pair
""" """
logging.debug("creating tunnel key for: %s, %s", node1_id, node2_id) logger.debug("creating tunnel key for: %s, %s", node1_id, node2_id)
key = ( key = (
(self.session.id << 16) (self.session.id << 16)
^ utils.hashkey(node1_id) ^ utils.hashkey(node1_id)

94
daemon/core/emulator/session.py
View file

@ -62,6 +62,8 @@ from core.services.coreservices import CoreServices
from core.xml import corexml, corexmldeployment from core.xml import corexml, corexmldeployment
from core.xml.corexml import CoreXmlReader, CoreXmlWriter from core.xml.corexml import CoreXmlReader, CoreXmlWriter
logger = logging.getLogger(__name__)
# maps for converting from API call node type values to classes and vice versa # maps for converting from API call node type values to classes and vice versa
NODES: Dict[NodeTypes, Type[NodeBase]] = { NODES: Dict[NodeTypes, Type[NodeBase]] = {
NodeTypes.DEFAULT: CoreNode, NodeTypes.DEFAULT: CoreNode,
@ -197,7 +199,7 @@ class Session:
:raises core.CoreError: when objects to link is less than 2, or no common :raises core.CoreError: when objects to link is less than 2, or no common
networks are found networks are found
""" """
logging.info( logger.info(
"handling wireless linking node1(%s) node2(%s): %s", "handling wireless linking node1(%s) node2(%s): %s",
node1.name, node1.name,
node2.name, node2.name,
@ -208,7 +210,7 @@ class Session:
raise CoreError("no common network found for wireless link/unlink") raise CoreError("no common network found for wireless link/unlink")
for common_network, iface1, iface2 in common_networks: for common_network, iface1, iface2 in common_networks:
if not isinstance(common_network, (WlanNode, EmaneNet)): if not isinstance(common_network, (WlanNode, EmaneNet)):
logging.info( logger.info(
"skipping common network that is not wireless/emane: %s", "skipping common network that is not wireless/emane: %s",
common_network, common_network,
) )
@ -263,7 +265,7 @@ class Session:
else: else:
# peer to peer link # peer to peer link
if isinstance(node1, CoreNodeBase) and isinstance(node2, CoreNodeBase): if isinstance(node1, CoreNodeBase) and isinstance(node2, CoreNodeBase):
logging.info("linking ptp: %s - %s", node1.name, node2.name) logger.info("linking ptp: %s - %s", node1.name, node2.name)
start = self.state.should_start() start = self.state.should_start()
ptp = self.create_node(PtpNet, start) ptp = self.create_node(PtpNet, start)
iface1 = node1.new_iface(ptp, iface1_data) iface1 = node1.new_iface(ptp, iface1_data)
@ -286,7 +288,7 @@ class Session:
elif isinstance(node1, CoreNetworkBase) and isinstance( elif isinstance(node1, CoreNetworkBase) and isinstance(
node2, CoreNetworkBase node2, CoreNetworkBase
): ):
logging.info( logger.info(
"linking network to network: %s - %s", node1.name, node2.name "linking network to network: %s - %s", node1.name, node2.name
) )
iface1 = node1.linknet(node2) iface1 = node1.linknet(node2)
@ -303,10 +305,10 @@ class Session:
# configure tunnel nodes # configure tunnel nodes
key = options.key key = options.key
if isinstance(node1, TunnelNode): if isinstance(node1, TunnelNode):
logging.info("setting tunnel key for: %s", node1.name) logger.info("setting tunnel key for: %s", node1.name)
node1.setkey(key, iface1_data) node1.setkey(key, iface1_data)
if isinstance(node2, TunnelNode): if isinstance(node2, TunnelNode):
logging.info("setting tunnel key for: %s", node2.name) logger.info("setting tunnel key for: %s", node2.name)
node2.setkey(key, iface2_data) node2.setkey(key, iface2_data)
self.sdt.add_link(node1_id, node2_id) self.sdt.add_link(node1_id, node2_id)
return iface1, iface2 return iface1, iface2
@ -332,7 +334,7 @@ class Session:
""" """
node1 = self.get_node(node1_id, NodeBase) node1 = self.get_node(node1_id, NodeBase)
node2 = self.get_node(node2_id, NodeBase) node2 = self.get_node(node2_id, NodeBase)
logging.info( logger.info(
"deleting link(%s) node(%s):interface(%s) node(%s):interface(%s)", "deleting link(%s) node(%s):interface(%s) node(%s):interface(%s)",
link_type.name, link_type.name,
node1.name, node1.name,
@ -409,7 +411,7 @@ class Session:
options = LinkOptions() options = LinkOptions()
node1 = self.get_node(node1_id, NodeBase) node1 = self.get_node(node1_id, NodeBase)
node2 = self.get_node(node2_id, NodeBase) node2 = self.get_node(node2_id, NodeBase)
logging.info( logger.info(
"update link(%s) node(%s):interface(%s) node(%s):interface(%s)", "update link(%s) node(%s):interface(%s) node(%s):interface(%s)",
link_type.name, link_type.name,
node1.name, node1.name,
@ -525,7 +527,7 @@ class Session:
raise CoreError(f"invalid distributed server: {options.server}") raise CoreError(f"invalid distributed server: {options.server}")
# create node # create node
logging.info( logger.info(
"creating node(%s) id(%s) name(%s) start(%s)", "creating node(%s) id(%s) name(%s) start(%s)",
_class.__name__, _class.__name__,
_id, _id,
@ -547,11 +549,11 @@ class Session:
# add services to needed nodes # add services to needed nodes
if isinstance(node, (CoreNode, PhysicalNode)): if isinstance(node, (CoreNode, PhysicalNode)):
node.type = options.model node.type = options.model
logging.debug("set node type: %s", node.type) logger.debug("set node type: %s", node.type)
self.services.add_services(node, node.type, options.services) self.services.add_services(node, node.type, options.services)
# add config services # add config services
logging.info("setting node config services: %s", options.config_services) logger.info("setting node config services: %s", options.config_services)
for name in options.config_services: for name in options.config_services:
service_class = self.service_manager.get_service(name) service_class = self.service_manager.get_service(name)
node.add_config_service(service_class) node.add_config_service(service_class)
@ -638,7 +640,7 @@ class Session:
:return: True if active, False otherwise :return: True if active, False otherwise
""" """
result = self.state in {EventTypes.RUNTIME_STATE, EventTypes.DATACOLLECT_STATE} result = self.state in {EventTypes.RUNTIME_STATE, EventTypes.DATACOLLECT_STATE}
logging.info("session(%s) checking if active: %s", self.id, result) logger.info("session(%s) checking if active: %s", self.id, result)
return result return result
def open_xml(self, file_path: Path, start: bool = False) -> None: def open_xml(self, file_path: Path, start: bool = False) -> None:
@ -649,7 +651,7 @@ class Session:
:param start: instantiate session if true, false otherwise :param start: instantiate session if true, false otherwise
:return: nothing :return: nothing
""" """
logging.info("opening xml: %s", file_path) logger.info("opening xml: %s", file_path)
# clear out existing session # clear out existing session
self.clear() self.clear()
# set state and read xml # set state and read xml
@ -684,7 +686,7 @@ class Session:
:param src_name: source name :param src_name: source name
:return: nothing :return: nothing
""" """
logging.info( logger.info(
"setting state hook: %s - %s source(%s)", state, file_name, src_name "setting state hook: %s - %s source(%s)", state, file_name, src_name
) )
hook = file_name, data hook = file_name, data
@ -693,7 +695,7 @@ class Session:
# immediately run a hook if it is in the current state # immediately run a hook if it is in the current state
if self.state == state: if self.state == state:
logging.info("immediately running new state hook") logger.info("immediately running new state hook")
self.run_hook(hook) self.run_hook(hook)
def add_node_file( def add_node_file(
@ -766,9 +768,9 @@ class Session:
Shutdown all session nodes and remove the session directory. Shutdown all session nodes and remove the session directory.
""" """
if self.state == EventTypes.SHUTDOWN_STATE: if self.state == EventTypes.SHUTDOWN_STATE:
logging.info("session(%s) state(%s) already shutdown", self.id, self.state) logger.info("session(%s) state(%s) already shutdown", self.id, self.state)
else: else:
logging.info("session(%s) state(%s) shutting down", self.id, self.state) logger.info("session(%s) state(%s) shutting down", self.id, self.state)
self.set_state(EventTypes.SHUTDOWN_STATE, send_event=True) self.set_state(EventTypes.SHUTDOWN_STATE, send_event=True)
# clear out current core session # clear out current core session
self.clear() self.clear()
@ -861,7 +863,7 @@ class Session:
return return
self.state = state self.state = state
self.state_time = time.monotonic() self.state_time = time.monotonic()
logging.info("changing session(%s) to state %s", self.id, state.name) logger.info("changing session(%s) to state %s", self.id, state.name)
self.write_state(state) self.write_state(state)
self.run_hooks(state) self.run_hooks(state)
self.run_state_hooks(state) self.run_state_hooks(state)
@ -881,7 +883,7 @@ class Session:
with state_file.open("w") as f: with state_file.open("w") as f:
f.write(f"{state.value} {state.name}\n") f.write(f"{state.value} {state.name}\n")
except IOError: except IOError:
logging.exception("error writing state file: %s", state.name) logger.exception("error writing state file: %s", state.name)
def run_hooks(self, state: EventTypes) -> None: def run_hooks(self, state: EventTypes) -> None:
""" """
@ -903,7 +905,7 @@ class Session:
:return: nothing :return: nothing
""" """
file_name, data = hook file_name, data = hook
logging.info("running hook %s", file_name) logger.info("running hook %s", file_name)
file_path = self.directory / file_name file_path = self.directory / file_name
log_path = self.directory / f"{file_name}.log" log_path = self.directory / f"{file_name}.log"
try: try:
@ -920,7 +922,7 @@ class Session:
env=self.get_environment(), env=self.get_environment(),
) )
except (IOError, subprocess.CalledProcessError): except (IOError, subprocess.CalledProcessError):
logging.exception("error running hook: %s", file_path) logger.exception("error running hook: %s", file_path)
def run_state_hooks(self, state: EventTypes) -> None: def run_state_hooks(self, state: EventTypes) -> None:
""" """
@ -937,7 +939,7 @@ class Session:
hook(state) hook(state)
except Exception: except Exception:
message = f"exception occurred when running {state.name} state hook: {hook}" message = f"exception occurred when running {state.name} state hook: {hook}"
logging.exception(message) logger.exception(message)
self.exception(ExceptionLevels.ERROR, "Session.run_state_hooks", message) self.exception(ExceptionLevels.ERROR, "Session.run_state_hooks", message)
def add_state_hook( def add_state_hook(
@ -1022,7 +1024,7 @@ class Session:
try: try:
utils.load_config(path, env) utils.load_config(path, env)
except IOError: except IOError:
logging.exception("error reading environment file: %s", path) logger.exception("error reading environment file: %s", path)
return env return env
def set_thumbnail(self, thumb_file: Path) -> None: def set_thumbnail(self, thumb_file: Path) -> None:
@ -1033,7 +1035,7 @@ class Session:
:return: nothing :return: nothing
""" """
if not thumb_file.is_file(): if not thumb_file.is_file():
logging.error("thumbnail file to set does not exist: %s", thumb_file) logger.error("thumbnail file to set does not exist: %s", thumb_file)
self.thumbnail = None self.thumbnail = None
return return
dst_path = self.directory / thumb_file.name dst_path = self.directory / thumb_file.name
@ -1054,7 +1056,7 @@ class Session:
gid = self.directory.stat().st_gid gid = self.directory.stat().st_gid
os.chown(self.directory, uid, gid) os.chown(self.directory, uid, gid)
except IOError: except IOError:
logging.exception("failed to set permission on %s", self.directory) logger.exception("failed to set permission on %s", self.directory)
self.user = user self.user = user
def create_node( def create_node(
@ -1111,7 +1113,7 @@ class Session:
with self.nodes_lock: with self.nodes_lock:
if _id in self.nodes: if _id in self.nodes:
node = self.nodes.pop(_id) node = self.nodes.pop(_id)
logging.info("deleted node(%s)", node.name) logger.info("deleted node(%s)", node.name)
if node: if node:
node.shutdown() node.shutdown()
self.sdt.delete_node(_id) self.sdt.delete_node(_id)
@ -1144,7 +1146,7 @@ class Session:
for _id, node in self.nodes.items(): for _id, node in self.nodes.items():
f.write(f"{_id} {node.name} {node.apitype} {type(node)}\n") f.write(f"{_id} {node.name} {node.apitype} {type(node)}\n")
except IOError: except IOError:
logging.exception("error writing nodes file") logger.exception("error writing nodes file")
def exception( def exception(
self, level: ExceptionLevels, source: str, text: str, node_id: int = None self, level: ExceptionLevels, source: str, text: str, node_id: int = None
@ -1235,13 +1237,13 @@ class Session:
""" """
# this is called from instantiate() after receiving an event message # this is called from instantiate() after receiving an event message
# for the instantiation state # for the instantiation state
logging.debug( logger.debug(
"session(%s) checking if not in runtime state, current state: %s", "session(%s) checking if not in runtime state, current state: %s",
self.id, self.id,
self.state.name, self.state.name,
) )
if self.state == EventTypes.RUNTIME_STATE: if self.state == EventTypes.RUNTIME_STATE:
logging.info("valid runtime state found, returning") logger.info("valid runtime state found, returning")
return return
# start event loop and set to runtime # start event loop and set to runtime
self.event_loop.run() self.event_loop.run()
@ -1255,11 +1257,11 @@ class Session:
:return: nothing :return: nothing
""" """
if self.state.already_collected(): if self.state.already_collected():
logging.info( logger.info(
"session(%s) state(%s) already data collected", self.id, self.state "session(%s) state(%s) already data collected", self.id, self.state
) )
return return
logging.info("session(%s) state(%s) data collection", self.id, self.state) logger.info("session(%s) state(%s) data collection", self.id, self.state)
self.set_state(EventTypes.DATACOLLECT_STATE, send_event=True) self.set_state(EventTypes.DATACOLLECT_STATE, send_event=True)
# stop event loop # stop event loop
@ -1302,7 +1304,7 @@ class Session:
:param node: node to boot :param node: node to boot
:return: nothing :return: nothing
""" """
logging.info("booting node(%s): %s", node.name, [x.name for x in node.services]) logger.info("booting node(%s): %s", node.name, [x.name for x in node.services])
self.services.boot_services(node) self.services.boot_services(node)
node.start_config_services() node.start_config_services()
@ -1323,7 +1325,7 @@ class Session:
funcs.append((self.boot_node, (node,), {})) funcs.append((self.boot_node, (node,), {}))
results, exceptions = utils.threadpool(funcs) results, exceptions = utils.threadpool(funcs)
total = time.monotonic() - start total = time.monotonic() - start
logging.debug("boot run time: %s", total) logger.debug("boot run time: %s", total)
if not exceptions: if not exceptions:
self.update_control_iface_hosts() self.update_control_iface_hosts()
return exceptions return exceptions
@ -1351,7 +1353,7 @@ class Session:
""" """
d0 = self.options.get_config("controlnetif0") d0 = self.options.get_config("controlnetif0")
if d0: if d0:
logging.error("controlnet0 cannot be assigned with a host interface") logger.error("controlnet0 cannot be assigned with a host interface")
d1 = self.options.get_config("controlnetif1") d1 = self.options.get_config("controlnetif1")
d2 = self.options.get_config("controlnetif2") d2 = self.options.get_config("controlnetif2")
d3 = self.options.get_config("controlnetif3") d3 = self.options.get_config("controlnetif3")
@ -1396,7 +1398,7 @@ class Session:
:param conf_required: flag to check if conf is required :param conf_required: flag to check if conf is required
:return: control net node :return: control net node
""" """
logging.debug( logger.debug(
"add/remove control net: index(%s) remove(%s) conf_required(%s)", "add/remove control net: index(%s) remove(%s) conf_required(%s)",
net_index, net_index,
remove, remove,
@ -1410,7 +1412,7 @@ class Session:
return None return None
else: else:
prefix_spec = CtrlNet.DEFAULT_PREFIX_LIST[net_index] prefix_spec = CtrlNet.DEFAULT_PREFIX_LIST[net_index]
logging.debug("prefix spec: %s", prefix_spec) logger.debug("prefix spec: %s", prefix_spec)
server_iface = self.get_control_net_server_ifaces()[net_index] server_iface = self.get_control_net_server_ifaces()[net_index]
# return any existing controlnet bridge # return any existing controlnet bridge
@ -1433,7 +1435,7 @@ class Session:
if net_index == 0: if net_index == 0:
updown_script = self.options.get_config("controlnet_updown_script") updown_script = self.options.get_config("controlnet_updown_script")
if not updown_script: if not updown_script:
logging.debug("controlnet updown script not configured") logger.debug("controlnet updown script not configured")
prefixes = prefix_spec.split() prefixes = prefix_spec.split()
if len(prefixes) > 1: if len(prefixes) > 1:
@ -1447,7 +1449,7 @@ class Session:
else: else:
prefix = prefixes[0] prefix = prefixes[0]
logging.info( logger.info(
"controlnet(%s) prefix(%s) updown(%s) serverintf(%s)", "controlnet(%s) prefix(%s) updown(%s) serverintf(%s)",
_id, _id,
prefix, prefix,
@ -1510,7 +1512,7 @@ class Session:
msg = f"Control interface not added to node {node.id}. " msg = f"Control interface not added to node {node.id}. "
msg += f"Invalid control network prefix ({control_net.prefix}). " msg += f"Invalid control network prefix ({control_net.prefix}). "
msg += "A longer prefix length may be required for this many nodes." msg += "A longer prefix length may be required for this many nodes."
logging.exception(msg) logger.exception(msg)
def update_control_iface_hosts( def update_control_iface_hosts(
self, net_index: int = 0, remove: bool = False self, net_index: int = 0, remove: bool = False
@ -1528,12 +1530,12 @@ class Session:
try: try:
control_net = self.get_control_net(net_index) control_net = self.get_control_net(net_index)
except CoreError: except CoreError:
logging.exception("error retrieving control net node") logger.exception("error retrieving control net node")
return return
header = f"CORE session {self.id} host entries" header = f"CORE session {self.id} host entries"
if remove: if remove:
logging.info("Removing /etc/hosts file entries.") logger.info("Removing /etc/hosts file entries.")
utils.file_demunge("/etc/hosts", header) utils.file_demunge("/etc/hosts", header)
return return
@ -1543,7 +1545,7 @@ class Session:
for ip in iface.ips(): for ip in iface.ips():
entries.append(f"{ip.ip} {name}") entries.append(f"{ip.ip} {name}")
logging.info("Adding %d /etc/hosts file entries.", len(entries)) logger.info("Adding %d /etc/hosts file entries.", len(entries))
utils.file_munge("/etc/hosts", header, "\n".join(entries) + "\n") utils.file_munge("/etc/hosts", header, "\n".join(entries) + "\n")
def runtime(self) -> float: def runtime(self) -> float:
@ -1572,7 +1574,7 @@ class Session:
current_time = self.runtime() current_time = self.runtime()
if current_time > 0: if current_time > 0:
if event_time <= current_time: if event_time <= current_time:
logging.warning( logger.warning(
"could not schedule past event for time %s (run time is now %s)", "could not schedule past event for time %s (run time is now %s)",
event_time, event_time,
current_time, current_time,
@ -1584,7 +1586,7 @@ class Session:
) )
if not name: if not name:
name = "" name = ""
logging.info( logger.info(
"scheduled event %s at time %s data=%s", "scheduled event %s at time %s data=%s",
name, name,
event_time + current_time, event_time + current_time,
@ -1603,12 +1605,12 @@ class Session:
:return: nothing :return: nothing
""" """
if data is None: if data is None:
logging.warning("no data for event node(%s) name(%s)", node_id, name) logger.warning("no data for event node(%s) name(%s)", node_id, name)
return return
now = self.runtime() now = self.runtime()
if not name: if not name:
name = "" name = ""
logging.info("running event %s at time %s cmd=%s", name, now, data) logger.info("running event %s at time %s cmd=%s", name, now, data)
if not node_id: if not node_id:
utils.mute_detach(data) utils.mute_detach(data)
else: else:

5
daemon/core/gui/app.py
View file

@ -22,6 +22,7 @@ from core.gui.statusbar import StatusBar
from core.gui.themes import PADY from core.gui.themes import PADY
from core.gui.toolbar import Toolbar from core.gui.toolbar import Toolbar
logger = logging.getLogger(__name__)
WIDTH: int = 1000 WIDTH: int = 1000
HEIGHT: int = 800 HEIGHT: int = 800
@ -171,7 +172,7 @@ class Application(ttk.Frame):
def show_grpc_exception( def show_grpc_exception(
self, message: str, e: grpc.RpcError, blocking: bool = False self, message: str, e: grpc.RpcError, blocking: bool = False
) -> None: ) -> None:
logging.exception("app grpc exception", exc_info=e) logger.exception("app grpc exception", exc_info=e)
dialog = ErrorDialog(self, "GRPC Exception", message, e.details()) dialog = ErrorDialog(self, "GRPC Exception", message, e.details())
if blocking: if blocking:
dialog.show() dialog.show()
@ -179,7 +180,7 @@ class Application(ttk.Frame):
self.after(0, lambda: dialog.show()) self.after(0, lambda: dialog.show())
def show_exception(self, message: str, e: Exception) -> None: def show_exception(self, message: str, e: Exception) -> None:
logging.exception("app exception", exc_info=e) logger.exception("app exception", exc_info=e)
self.after( self.after(
0, lambda: ErrorDialog(self, "App Exception", message, str(e)).show() 0, lambda: ErrorDialog(self, "App Exception", message, str(e)).show()
) )

94
daemon/core/gui/coreclient.py
View file

@ -46,6 +46,8 @@ from core.gui.graph.shape import Shape
from core.gui.interface import InterfaceManager from core.gui.interface import InterfaceManager
from core.gui.nodeutils import NodeDraw from core.gui.nodeutils import NodeDraw
logger = logging.getLogger(__name__)
if TYPE_CHECKING: if TYPE_CHECKING:
from core.gui.app import Application from core.gui.app import Application
@ -150,7 +152,7 @@ class CoreClient:
if not self.session or event.source == GUI_SOURCE: if not self.session or event.source == GUI_SOURCE:
return return
if event.session_id != self.session.id: if event.session_id != self.session.id:
logging.warning( logger.warning(
"ignoring event session(%s) current(%s)", "ignoring event session(%s) current(%s)",
event.session_id, event.session_id,
self.session.id, self.session.id,
@ -159,7 +161,7 @@ class CoreClient:
if event.link_event: if event.link_event:
self.app.after(0, self.handle_link_event, event.link_event) self.app.after(0, self.handle_link_event, event.link_event)
elif event.session_event: elif event.session_event:
logging.info("session event: %s", event) logger.info("session event: %s", event)
session_event = event.session_event session_event = event.session_event
if session_event.event <= SessionState.SHUTDOWN.value: if session_event.event <= SessionState.SHUTDOWN.value:
self.session.state = SessionState(session_event.event) self.session.state = SessionState(session_event.event)
@ -174,22 +176,22 @@ class CoreClient:
else: else:
dialog.set_pause() dialog.set_pause()
else: else:
logging.warning("unknown session event: %s", session_event) logger.warning("unknown session event: %s", session_event)
elif event.node_event: elif event.node_event:
self.app.after(0, self.handle_node_event, event.node_event) self.app.after(0, self.handle_node_event, event.node_event)
elif event.config_event: elif event.config_event:
logging.info("config event: %s", event) logger.info("config event: %s", event)
elif event.exception_event: elif event.exception_event:
self.handle_exception_event(event.exception_event) self.handle_exception_event(event.exception_event)
else: else:
logging.info("unhandled event: %s", event) logger.info("unhandled event: %s", event)
def handle_link_event(self, event: LinkEvent) -> None: def handle_link_event(self, event: LinkEvent) -> None:
logging.debug("Link event: %s", event) logger.debug("Link event: %s", event)
node1_id = event.link.node1_id node1_id = event.link.node1_id
node2_id = event.link.node2_id node2_id = event.link.node2_id
if node1_id == node2_id: if node1_id == node2_id:
logging.warning("ignoring links with loops: %s", event) logger.warning("ignoring links with loops: %s", event)
return return
canvas_node1 = self.canvas_nodes[node1_id] canvas_node1 = self.canvas_nodes[node1_id]
canvas_node2 = self.canvas_nodes[node2_id] canvas_node2 = self.canvas_nodes[node2_id]
@ -207,7 +209,7 @@ class CoreClient:
canvas_node1, canvas_node2, event.link canvas_node1, canvas_node2, event.link
) )
else: else:
logging.warning("unknown link event: %s", event) logger.warning("unknown link event: %s", event)
else: else:
if event.message_type == MessageType.ADD: if event.message_type == MessageType.ADD:
self.app.manager.add_wired_edge(canvas_node1, canvas_node2, event.link) self.app.manager.add_wired_edge(canvas_node1, canvas_node2, event.link)
@ -216,10 +218,10 @@ class CoreClient:
elif event.message_type == MessageType.NONE: elif event.message_type == MessageType.NONE:
self.app.manager.update_wired_edge(event.link) self.app.manager.update_wired_edge(event.link)
else: else:
logging.warning("unknown link event: %s", event) logger.warning("unknown link event: %s", event)
def handle_node_event(self, event: NodeEvent) -> None: def handle_node_event(self, event: NodeEvent) -> None:
logging.debug("node event: %s", event) logger.debug("node event: %s", event)
node = event.node node = event.node
if event.message_type == MessageType.NONE: if event.message_type == MessageType.NONE:
canvas_node = self.canvas_nodes[node.id] canvas_node = self.canvas_nodes[node.id]
@ -235,10 +237,10 @@ class CoreClient:
canvas_node.canvas.delete_selected_objects() canvas_node.canvas.delete_selected_objects()
elif event.message_type == MessageType.ADD: elif event.message_type == MessageType.ADD:
if node.id in self.session.nodes: if node.id in self.session.nodes:
logging.error("core node already exists: %s", node) logger.error("core node already exists: %s", node)
self.app.manager.add_core_node(node) self.app.manager.add_core_node(node)
else: else:
logging.warning("unknown node event: %s", event) logger.warning("unknown node event: %s", event)
def enable_throughputs(self) -> None: def enable_throughputs(self) -> None:
self.handling_throughputs = self.client.throughputs( self.handling_throughputs = self.client.throughputs(
@ -272,24 +274,24 @@ class CoreClient:
def handle_throughputs(self, event: ThroughputsEvent) -> None: def handle_throughputs(self, event: ThroughputsEvent) -> None:
if event.session_id != self.session.id: if event.session_id != self.session.id:
logging.warning( logger.warning(
"ignoring throughput event session(%s) current(%s)", "ignoring throughput event session(%s) current(%s)",
event.session_id, event.session_id,
self.session.id, self.session.id,
) )
return return
logging.debug("handling throughputs event: %s", event) logger.debug("handling throughputs event: %s", event)
self.app.after(0, self.app.manager.set_throughputs, event) self.app.after(0, self.app.manager.set_throughputs, event)
def handle_cpu_event(self, event: core_pb2.CpuUsageEvent) -> None: def handle_cpu_event(self, event: core_pb2.CpuUsageEvent) -> None:
self.app.after(0, self.app.statusbar.set_cpu, event.usage) self.app.after(0, self.app.statusbar.set_cpu, event.usage)
def handle_exception_event(self, event: ExceptionEvent) -> None: def handle_exception_event(self, event: ExceptionEvent) -> None:
logging.info("exception event: %s", event) logger.info("exception event: %s", event)
self.app.statusbar.add_alert(event) self.app.statusbar.add_alert(event)
def join_session(self, session_id: int) -> None: def join_session(self, session_id: int) -> None:
logging.info("joining session(%s)", session_id) logger.info("joining session(%s)", session_id)
self.reset() self.reset()
try: try:
self.session = self.client.get_session(session_id) self.session = self.client.get_session(session_id)
@ -314,7 +316,7 @@ class CoreClient:
# canvas setting # canvas setting
config = self.session.metadata config = self.session.metadata
canvas_config = config.get("canvas") canvas_config = config.get("canvas")
logging.debug("canvas metadata: %s", canvas_config) logger.debug("canvas metadata: %s", canvas_config)
if canvas_config: if canvas_config:
canvas_config = json.loads(canvas_config) canvas_config = json.loads(canvas_config)
self.app.manager.parse_metadata(canvas_config) self.app.manager.parse_metadata(canvas_config)
@ -324,14 +326,14 @@ class CoreClient:
if shapes_config: if shapes_config:
shapes_config = json.loads(shapes_config) shapes_config = json.loads(shapes_config)
for shape_config in shapes_config: for shape_config in shapes_config:
logging.debug("loading shape: %s", shape_config) logger.debug("loading shape: %s", shape_config)
Shape.from_metadata(self.app, shape_config) Shape.from_metadata(self.app, shape_config)
# load edges config # load edges config
edges_config = config.get("edges") edges_config = config.get("edges")
if edges_config: if edges_config:
edges_config = json.loads(edges_config) edges_config = json.loads(edges_config)
logging.info("edges config: %s", edges_config) logger.info("edges config: %s", edges_config)
for edge_config in edges_config: for edge_config in edges_config:
edge = self.links[edge_config["token"]] edge = self.links[edge_config["token"]]
edge.width = edge_config["width"] edge.width = edge_config["width"]
@ -347,7 +349,7 @@ class CoreClient:
if canvas_node: if canvas_node:
canvas_node.hide() canvas_node.hide()
else: else:
logging.warning("invalid node to hide: %s", _id) logger.warning("invalid node to hide: %s", _id)
def create_new_session(self) -> None: def create_new_session(self) -> None:
""" """
@ -355,7 +357,7 @@ class CoreClient:
""" """
try: try:
session_id = self.client.create_session() session_id = self.client.create_session()
logging.info("created session: %s", session_id) logger.info("created session: %s", session_id)
self.join_session(session_id) self.join_session(session_id)
location_config = self.app.guiconfig.location location_config = self.app.guiconfig.location
self.session.location = SessionLocation( self.session.location = SessionLocation(
@ -377,7 +379,7 @@ class CoreClient:
session_id = self.session.id session_id = self.session.id
try: try:
response = self.client.delete_session(session_id) response = self.client.delete_session(session_id)
logging.info("deleted session(%s), Result: %s", session_id, response) logger.info("deleted session(%s), Result: %s", session_id, response)
except grpc.RpcError as e: except grpc.RpcError as e:
self.app.show_grpc_exception("Delete Session Error", e) self.app.show_grpc_exception("Delete Session Error", e)
@ -419,7 +421,7 @@ class CoreClient:
dialog = SessionsDialog(self.app, True) dialog = SessionsDialog(self.app, True)
dialog.show() dialog.show()
except grpc.RpcError as e: except grpc.RpcError as e:
logging.exception("core setup error") logger.exception("core setup error")
self.app.show_grpc_exception("Setup Error", e, blocking=True) self.app.show_grpc_exception("Setup Error", e, blocking=True)
self.app.close() self.app.close()
@ -456,7 +458,7 @@ class CoreClient:
result, exceptions = self.client.start_session( result, exceptions = self.client.start_session(
self.session, asymmetric_links self.session, asymmetric_links
) )
logging.info("start session(%s), result: %s", self.session.id, result) logger.info("start session(%s), result: %s", self.session.id, result)
if result: if result:
self.set_metadata() self.set_metadata()
except grpc.RpcError as e: except grpc.RpcError as e:
@ -469,7 +471,7 @@ class CoreClient:
result = False result = False
try: try:
result = self.client.stop_session(session_id) result = self.client.stop_session(session_id)
logging.info("stopped session(%s), result: %s", session_id, result) logger.info("stopped session(%s), result: %s", session_id, result)
except grpc.RpcError as e: except grpc.RpcError as e:
self.app.show_grpc_exception("Stop Session Error", e) self.app.show_grpc_exception("Stop Session Error", e)
return result return result
@ -513,7 +515,7 @@ class CoreClient:
canvas=canvas_config, shapes=shapes, edges=edges_config, hidden=hidden canvas=canvas_config, shapes=shapes, edges=edges_config, hidden=hidden
) )
response = self.client.set_session_metadata(self.session.id, metadata) response = self.client.set_session_metadata(self.session.id, metadata)
logging.debug("set session metadata %s, result: %s", metadata, response) logger.debug("set session metadata %s, result: %s", metadata, response)
def launch_terminal(self, node_id: int) -> None: def launch_terminal(self, node_id: int) -> None:
try: try:
@ -527,7 +529,7 @@ class CoreClient:
return return
node_term = self.client.get_node_terminal(self.session.id, node_id) node_term = self.client.get_node_terminal(self.session.id, node_id)
cmd = f"{terminal} {node_term} &" cmd = f"{terminal} {node_term} &"
logging.info("launching terminal %s", cmd) logger.info("launching terminal %s", cmd)
os.system(cmd) os.system(cmd)
except grpc.RpcError as e: except grpc.RpcError as e:
self.app.show_grpc_exception("Node Terminal Error", e) self.app.show_grpc_exception("Node Terminal Error", e)
@ -540,16 +542,16 @@ class CoreClient:
Save core session as to an xml file Save core session as to an xml file
""" """
if not file_path and not self.session.file: if not file_path and not self.session.file:
logging.error("trying to save xml for session with no file") logger.error("trying to save xml for session with no file")
return return
if not file_path: if not file_path:
file_path = str(self.session.file) file_path = str(self.session.file)
try: try:
if not self.is_runtime(): if not self.is_runtime():
logging.debug("Send session data to the daemon") logger.debug("Send session data to the daemon")
self.send_data() self.send_data()
self.client.save_xml(self.session.id, file_path) self.client.save_xml(self.session.id, file_path)
logging.info("saved xml file %s", file_path) logger.info("saved xml file %s", file_path)
except grpc.RpcError as e: except grpc.RpcError as e:
self.app.show_grpc_exception("Save XML Error", e) self.app.show_grpc_exception("Save XML Error", e)
@ -559,7 +561,7 @@ class CoreClient:
""" """
try: try:
result, session_id = self._client.open_xml(file_path) result, session_id = self._client.open_xml(file_path)
logging.info( logger.info(
"open xml file %s, result(%s) session(%s)", "open xml file %s, result(%s) session(%s)",
file_path, file_path,
result, result,
@ -573,14 +575,14 @@ class CoreClient:
node_service = self.client.get_node_service( node_service = self.client.get_node_service(
self.session.id, node_id, service_name self.session.id, node_id, service_name
) )
logging.debug( logger.debug(
"get node(%s) service(%s): %s", node_id, service_name, node_service "get node(%s) service(%s): %s", node_id, service_name, node_service
) )
return node_service return node_service
def set_node_service(self, node_id: int, config: ServiceConfig) -> NodeServiceData: def set_node_service(self, node_id: int, config: ServiceConfig) -> NodeServiceData:
result = self.client.set_node_service(self.session.id, config) result = self.client.set_node_service(self.session.id, config)
logging.info("set node service result(%s): %s", result, config) logger.info("set node service result(%s): %s", result, config)
return self.client.get_node_service(self.session.id, node_id, config.service) return self.client.get_node_service(self.session.id, node_id, config.service)
def get_node_service_file( def get_node_service_file(
@ -589,7 +591,7 @@ class CoreClient:
data = self.client.get_node_service_file( data = self.client.get_node_service_file(
self.session.id, node_id, service_name, file_name self.session.id, node_id, service_name, file_name
) )
logging.debug( logger.debug(
"get service file for node(%s), service: %s, file: %s, data: %s", "get service file for node(%s), service: %s, file: %s, data: %s",
node_id, node_id,
service_name, service_name,
@ -603,7 +605,7 @@ class CoreClient:
) -> None: ) -> None:
config = ServiceFileConfig(node_id, service_name, file_name, data) config = ServiceFileConfig(node_id, service_name, file_name, data)
result = self.client.set_node_service_file(self.session.id, config) result = self.client.set_node_service_file(self.session.id, config)
logging.info("set service file config %s: %s", config, result) logger.info("set service file config %s: %s", config, result)
def create_nodes_and_links(self) -> None: def create_nodes_and_links(self) -> None:
""" """
@ -612,7 +614,7 @@ class CoreClient:
self.client.set_session_state(self.session.id, SessionState.DEFINITION) self.client.set_session_state(self.session.id, SessionState.DEFINITION)
for node in self.session.nodes.values(): for node in self.session.nodes.values():
node_id = self.client.add_node(self.session.id, node, source=GUI_SOURCE) node_id = self.client.add_node(self.session.id, node, source=GUI_SOURCE)
logging.debug("created node: %s", node_id) logger.debug("created node: %s", node_id)
asymmetric_links = [] asymmetric_links = []
for edge in self.links.values(): for edge in self.links.values():
self.add_link(edge.link) self.add_link(edge.link)
@ -648,7 +650,7 @@ class CoreClient:
""" """
Clean ups when done using grpc Clean ups when done using grpc
""" """
logging.debug("close grpc") logger.debug("close grpc")
self.client.close() self.client.close()
def next_node_id(self) -> int: def next_node_id(self) -> int:
@ -704,7 +706,7 @@ class CoreClient:
services = self.session.default_services.get(model) services = self.session.default_services.get(model)
if services: if services:
node.services = services.copy() node.services = services.copy()
logging.info( logger.info(
"add node(%s) to session(%s), coordinates(%s, %s)", "add node(%s) to session(%s), coordinates(%s, %s)",
node.name, node.name,
self.session.id, self.session.id,
@ -831,13 +833,13 @@ class CoreClient:
return config_service_protos return config_service_protos
def run(self, node_id: int) -> str: def run(self, node_id: int) -> str:
logging.info("running node(%s) cmd: %s", node_id, self.observer) logger.info("running node(%s) cmd: %s", node_id, self.observer)
_, output = self.client.node_command(self.session.id, node_id, self.observer) _, output = self.client.node_command(self.session.id, node_id, self.observer)
return output return output
def get_wlan_config(self, node_id: int) -> Dict[str, ConfigOption]: def get_wlan_config(self, node_id: int) -> Dict[str, ConfigOption]:
config = self.client.get_wlan_config(self.session.id, node_id) config = self.client.get_wlan_config(self.session.id, node_id)
logging.debug( logger.debug(
"get wlan configuration from node %s, result configuration: %s", "get wlan configuration from node %s, result configuration: %s",
node_id, node_id,
config, config,
@ -846,7 +848,7 @@ class CoreClient:
def get_mobility_config(self, node_id: int) -> Dict[str, ConfigOption]: def get_mobility_config(self, node_id: int) -> Dict[str, ConfigOption]:
config = self.client.get_mobility_config(self.session.id, node_id) config = self.client.get_mobility_config(self.session.id, node_id)
logging.debug( logger.debug(
"get mobility config from node %s, result configuration: %s", "get mobility config from node %s, result configuration: %s",
node_id, node_id,
config, config,
@ -861,7 +863,7 @@ class CoreClient:
config = self.client.get_emane_model_config( config = self.client.get_emane_model_config(
self.session.id, node_id, model, iface_id self.session.id, node_id, model, iface_id
) )
logging.debug( logger.debug(
"get emane model config: node id: %s, EMANE model: %s, " "get emane model config: node id: %s, EMANE model: %s, "
"interface: %s, config: %s", "interface: %s, config: %s",
node_id, node_id,
@ -873,17 +875,17 @@ class CoreClient:
def execute_script(self, script) -> None: def execute_script(self, script) -> None:
session_id = self.client.execute_script(script) session_id = self.client.execute_script(script)
logging.info("execute python script %s", session_id) logger.info("execute python script %s", session_id)
if session_id != -1: if session_id != -1:
self.join_session(session_id) self.join_session(session_id)
def add_link(self, link: Link) -> None: def add_link(self, link: Link) -> None:
result, _, _ = self.client.add_link(self.session.id, link, source=GUI_SOURCE) result, _, _ = self.client.add_link(self.session.id, link, source=GUI_SOURCE)
logging.debug("added link: %s", result) logger.debug("added link: %s", result)
if not result: if not result:
logging.error("error adding link: %s", link) logger.error("error adding link: %s", link)
def edit_link(self, link: Link) -> None: def edit_link(self, link: Link) -> None:
result = self.client.edit_link(self.session.id, link, source=GUI_SOURCE) result = self.client.edit_link(self.session.id, link, source=GUI_SOURCE)
if not result: if not result:
logging.error("error editing link: %s", link) logger.error("error editing link: %s", link)

4
daemon/core/gui/dialogs/canvaswallpaper.py
View file

@ -13,6 +13,8 @@ from core.gui.graph.graph import CanvasGraph
from core.gui.themes import PADX, PADY from core.gui.themes import PADX, PADY
from core.gui.widgets import image_chooser from core.gui.widgets import image_chooser
logger = logging.getLogger(__name__)
if TYPE_CHECKING: if TYPE_CHECKING:
from core.gui.app import Application from core.gui.app import Application
@ -167,5 +169,5 @@ class CanvasWallpaperDialog(Dialog):
try: try:
self.canvas.set_wallpaper(filename) self.canvas.set_wallpaper(filename)
except FileNotFoundError: except FileNotFoundError:
logging.error("invalid background: %s", filename) logger.error("invalid background: %s", filename)
self.destroy() self.destroy()

12
daemon/core/gui/dialogs/configserviceconfig.py
View file

@ -18,6 +18,8 @@ from core.gui.dialogs.dialog import Dialog
from core.gui.themes import FRAME_PAD, PADX, PADY from core.gui.themes import FRAME_PAD, PADX, PADY
from core.gui.widgets import CodeText, ConfigFrame, ListboxScroll from core.gui.widgets import CodeText, ConfigFrame, ListboxScroll
logger = logging.getLogger(__name__)
if TYPE_CHECKING: if TYPE_CHECKING:
from core.gui.app import Application from core.gui.app import Application
from core.gui.coreclient import CoreClient from core.gui.coreclient import CoreClient
@ -97,7 +99,7 @@ class ConfigServiceConfigDialog(Dialog):
if service_config: if service_config:
for key, value in service_config.config.items(): for key, value in service_config.config.items():
self.config[key].value = value self.config[key].value = value
logging.info("default config: %s", self.default_config) logger.info("default config: %s", self.default_config)
for file, data in service_config.templates.items(): for file, data in service_config.templates.items():
self.modified_files.add(file) self.modified_files.add(file)
self.temp_service_files[file] = data self.temp_service_files[file] = data
@ -181,7 +183,7 @@ class ConfigServiceConfigDialog(Dialog):
self.modes_combobox.bind("<<ComboboxSelected>>", self.handle_mode_changed) self.modes_combobox.bind("<<ComboboxSelected>>", self.handle_mode_changed)
self.modes_combobox.grid(row=0, column=1, sticky=tk.EW, pady=PADY) self.modes_combobox.grid(row=0, column=1, sticky=tk.EW, pady=PADY)
logging.info("config service config: %s", self.config) logger.info("config service config: %s", self.config)
self.config_frame = ConfigFrame(tab, self.app, self.config) self.config_frame = ConfigFrame(tab, self.app, self.config)
self.config_frame.draw_config() self.config_frame.draw_config()
self.config_frame.grid(sticky=tk.NSEW, pady=PADY) self.config_frame.grid(sticky=tk.NSEW, pady=PADY)
@ -328,7 +330,7 @@ class ConfigServiceConfigDialog(Dialog):
def handle_mode_changed(self, event: tk.Event) -> None: def handle_mode_changed(self, event: tk.Event) -> None:
mode = self.modes_combobox.get() mode = self.modes_combobox.get()
config = self.mode_configs[mode] config = self.mode_configs[mode]
logging.info("mode config: %s", config) logger.info("mode config: %s", config)
self.config_frame.set_values(config) self.config_frame.set_values(config)
def update_template_file_data(self, event: tk.Event) -> None: def update_template_file_data(self, event: tk.Event) -> None:
@ -350,7 +352,7 @@ class ConfigServiceConfigDialog(Dialog):
def click_defaults(self) -> None: def click_defaults(self) -> None:
self.node.config_service_configs.pop(self.service_name, None) self.node.config_service_configs.pop(self.service_name, None)
logging.info( logger.info(
"cleared config service config: %s", self.node.config_service_configs "cleared config service config: %s", self.node.config_service_configs
) )
self.temp_service_files = dict(self.original_service_files) self.temp_service_files = dict(self.original_service_files)
@ -358,7 +360,7 @@ class ConfigServiceConfigDialog(Dialog):
self.template_text.text.delete(1.0, "end") self.template_text.text.delete(1.0, "end")
self.template_text.text.insert("end", self.temp_service_files[filename]) self.template_text.text.insert("end", self.temp_service_files[filename])
if self.config_frame: if self.config_frame:
logging.info("resetting defaults: %s", self.default_config) logger.info("resetting defaults: %s", self.default_config)
self.config_frame.set_values(self.default_config) self.config_frame.set_values(self.default_config)
def click_copy(self) -> None: def click_copy(self) -> None:

8
daemon/core/gui/dialogs/customnodes.py
View file

@ -13,6 +13,8 @@ from core.gui.nodeutils import NodeDraw
from core.gui.themes import FRAME_PAD, PADX, PADY from core.gui.themes import FRAME_PAD, PADX, PADY
from core.gui.widgets import CheckboxList, ListboxScroll, image_chooser from core.gui.widgets import CheckboxList, ListboxScroll, image_chooser
logger = logging.getLogger(__name__)
if TYPE_CHECKING: if TYPE_CHECKING:
from core.gui.app import Application from core.gui.app import Application
@ -209,7 +211,7 @@ class CustomNodesDialog(Dialog):
name, node_draw.image_file, list(node_draw.services) name, node_draw.image_file, list(node_draw.services)
) )
self.app.guiconfig.nodes.append(custom_node) self.app.guiconfig.nodes.append(custom_node)
logging.info("saving custom nodes: %s", self.app.guiconfig.nodes) logger.info("saving custom nodes: %s", self.app.guiconfig.nodes)
self.app.save_config() self.app.save_config()
self.destroy() self.destroy()
@ -219,7 +221,7 @@ class CustomNodesDialog(Dialog):
image_file = str(Path(self.image_file).absolute()) image_file = str(Path(self.image_file).absolute())
custom_node = CustomNode(name, image_file, list(self.services)) custom_node = CustomNode(name, image_file, list(self.services))
node_draw = NodeDraw.from_custom(custom_node) node_draw = NodeDraw.from_custom(custom_node)
logging.info( logger.info(
"created new custom node (%s), image file (%s), services: (%s)", "created new custom node (%s), image file (%s), services: (%s)",
name, name,
image_file, image_file,
@ -239,7 +241,7 @@ class CustomNodesDialog(Dialog):
node_draw.image_file = str(Path(self.image_file).absolute()) node_draw.image_file = str(Path(self.image_file).absolute())
node_draw.image = self.image node_draw.image = self.image
node_draw.services = set(self.services) node_draw.services = set(self.services)
logging.debug( logger.debug(
"edit custom node (%s), image: (%s), services (%s)", "edit custom node (%s), image: (%s), services (%s)",
node_draw.model, node_draw.model,
node_draw.image_file, node_draw.image_file,

4
daemon/core/gui/dialogs/executepython.py
View file

@ -7,6 +7,8 @@ from core.gui.appconfig import SCRIPT_PATH
from core.gui.dialogs.dialog import Dialog from core.gui.dialogs.dialog import Dialog
from core.gui.themes import FRAME_PAD, PADX from core.gui.themes import FRAME_PAD, PADX
logger = logging.getLogger(__name__)
if TYPE_CHECKING: if TYPE_CHECKING:
from core.gui.app import Application from core.gui.app import Application
@ -83,6 +85,6 @@ class ExecutePythonDialog(Dialog):
def script_execute(self) -> None: def script_execute(self) -> None:
file = self.file_entry.get() file = self.file_entry.get()
options = self.option_entry.get() options = self.option_entry.get()
logging.info("Execute %s with options %s", file, options) logger.info("Execute %s with options %s", file, options)
self.app.core.execute_script(file) self.app.core.execute_script(file)
self.destroy() self.destroy()

6
daemon/core/gui/dialogs/find.py
View file

@ -6,6 +6,8 @@ from typing import TYPE_CHECKING, Optional
from core.gui.dialogs.dialog import Dialog from core.gui.dialogs.dialog import Dialog
from core.gui.themes import FRAME_PAD, PADX, PADY from core.gui.themes import FRAME_PAD, PADX, PADY
logger = logging.getLogger(__name__)
if TYPE_CHECKING: if TYPE_CHECKING:
from core.gui.app import Application from core.gui.app import Application
@ -139,8 +141,8 @@ class FindDialog(Dialog):
_x, _y, _, _ = canvas_node.canvas.bbox(canvas_node.id) _x, _y, _, _ = canvas_node.canvas.bbox(canvas_node.id)
oid = canvas_node.canvas.find_withtag("rectangle") oid = canvas_node.canvas.find_withtag("rectangle")
x0, y0, x1, y1 = canvas_node.canvas.bbox(oid[0]) x0, y0, x1, y1 = canvas_node.canvas.bbox(oid[0])
logging.debug("Dist to most left: %s", abs(x0 - _x)) logger.debug("Dist to most left: %s", abs(x0 - _x))
logging.debug("White canvas width: %s", abs(x0 - x1)) logger.debug("White canvas width: %s", abs(x0 - x1))
# calculate the node's location # calculate the node's location
# (as fractions of white canvas's width and height) # (as fractions of white canvas's width and height)

4
daemon/core/gui/dialogs/nodeconfig.py
View file

@ -17,6 +17,8 @@ from core.gui.dialogs.emaneconfig import EmaneModelDialog
from core.gui.themes import FRAME_PAD, PADX, PADY from core.gui.themes import FRAME_PAD, PADX, PADY
from core.gui.widgets import ListboxScroll, image_chooser from core.gui.widgets import ListboxScroll, image_chooser
logger = logging.getLogger(__name__)
if TYPE_CHECKING: if TYPE_CHECKING:
from core.gui.app import Application from core.gui.app import Application
from core.gui.graph.node import CanvasNode from core.gui.graph.node import CanvasNode
@ -261,7 +263,7 @@ class NodeConfigDialog(Dialog):
if nutils.is_rj45(self.node): if nutils.is_rj45(self.node):
ifaces = self.app.core.client.get_ifaces() ifaces = self.app.core.client.get_ifaces()
logging.debug("host machine available interfaces: %s", ifaces) logger.debug("host machine available interfaces: %s", ifaces)
ifaces_scroll = ListboxScroll(frame) ifaces_scroll = ListboxScroll(frame)
ifaces_scroll.listbox.config(state=state) ifaces_scroll.listbox.config(state=state)
ifaces_scroll.grid( ifaces_scroll.grid(

4
daemon/core/gui/dialogs/nodeconfigservice.py
View file

@ -12,6 +12,8 @@ from core.gui.dialogs.dialog import Dialog
from core.gui.themes import FRAME_PAD, PADX, PADY from core.gui.themes import FRAME_PAD, PADX, PADY
from core.gui.widgets import CheckboxList, ListboxScroll from core.gui.widgets import CheckboxList, ListboxScroll
logger = logging.getLogger(__name__)
if TYPE_CHECKING: if TYPE_CHECKING:
from core.gui.app import Application from core.gui.app import Application
@ -131,7 +133,7 @@ class NodeConfigServiceDialog(Dialog):
def click_save(self) -> None: def click_save(self) -> None:
self.node.config_services = self.current_services.copy() self.node.config_services = self.current_services.copy()
logging.info("saved node config services: %s", self.node.config_services) logger.info("saved node config services: %s", self.node.config_services)
self.destroy() self.destroy()
def click_cancel(self) -> None: def click_cancel(self) -> None:

4
daemon/core/gui/dialogs/preferences.py
View file

@ -9,6 +9,8 @@ from core.gui.dialogs.dialog import Dialog
from core.gui.themes import FRAME_PAD, PADX, PADY, scale_fonts from core.gui.themes import FRAME_PAD, PADX, PADY, scale_fonts
from core.gui.validation import LARGEST_SCALE, SMALLEST_SCALE from core.gui.validation import LARGEST_SCALE, SMALLEST_SCALE
logger = logging.getLogger(__name__)
if TYPE_CHECKING: if TYPE_CHECKING:
from core.gui.app import Application from core.gui.app import Application
@ -102,7 +104,7 @@ class PreferencesDialog(Dialog):
def theme_change(self, event: tk.Event) -> None: def theme_change(self, event: tk.Event) -> None:
theme = self.theme.get() theme = self.theme.get()
logging.info("changing theme: %s", theme) logger.info("changing theme: %s", theme)
self.app.style.theme_use(theme) self.app.style.theme_use(theme)
def click_save(self) -> None: def click_save(self) -> None:

6
daemon/core/gui/dialogs/serviceconfig.py
View file

@ -20,6 +20,8 @@ from core.gui.images import ImageEnum
from core.gui.themes import FRAME_PAD, PADX, PADY from core.gui.themes import FRAME_PAD, PADX, PADY
from core.gui.widgets import CodeText, ListboxScroll from core.gui.widgets import CodeText, ListboxScroll
logger = logging.getLogger(__name__)
if TYPE_CHECKING: if TYPE_CHECKING:
from core.gui.app import Application from core.gui.app import Application
from core.gui.coreclient import CoreClient from core.gui.coreclient import CoreClient
@ -393,7 +395,7 @@ class ServiceConfigDialog(Dialog):
1.0, "end" 1.0, "end"
) )
else: else:
logging.debug("file already existed") logger.debug("file already existed")
def delete_filename(self) -> None: def delete_filename(self) -> None:
cbb = self.filename_combobox cbb = self.filename_combobox
@ -601,7 +603,7 @@ class ServiceConfigDialog(Dialog):
i = dirs.index(d) i = dirs.index(d)
self.dir_list.listbox.delete(i) self.dir_list.listbox.delete(i)
except ValueError: except ValueError:
logging.debug("directory is not in the list") logger.debug("directory is not in the list")
self.directory_entry.delete(0, "end") self.directory_entry.delete(0, "end")
def directory_select(self, event) -> None: def directory_select(self, event) -> None:

4
daemon/core/gui/dialogs/sessionoptions.py
View file

@ -10,6 +10,8 @@ from core.gui.dialogs.dialog import Dialog
from core.gui.themes import PADX, PADY from core.gui.themes import PADX, PADY
from core.gui.widgets import ConfigFrame from core.gui.widgets import ConfigFrame
logger = logging.getLogger(__name__)
if TYPE_CHECKING: if TYPE_CHECKING:
from core.gui.app import Application from core.gui.app import Application
@ -55,7 +57,7 @@ class SessionOptionsDialog(Dialog):
try: try:
session_id = self.app.core.session.id session_id = self.app.core.session.id
result = self.app.core.client.set_session_options(session_id, config) result = self.app.core.client.set_session_options(session_id, config)
logging.info("saved session config: %s", result) logger.info("saved session config: %s", result)
except grpc.RpcError as e: except grpc.RpcError as e:
self.app.show_grpc_exception("Set Session Options Error", e) self.app.show_grpc_exception("Set Session Options Error", e)
self.destroy() self.destroy()

8
daemon/core/gui/dialogs/sessions.py
View file

@ -12,6 +12,8 @@ from core.gui.images import ImageEnum
from core.gui.task import ProgressTask from core.gui.task import ProgressTask
from core.gui.themes import PADX, PADY from core.gui.themes import PADX, PADY
logger = logging.getLogger(__name__)
if TYPE_CHECKING: if TYPE_CHECKING:
from core.gui.app import Application from core.gui.app import Application
@ -31,7 +33,7 @@ class SessionsDialog(Dialog):
def get_sessions(self) -> List[SessionSummary]: def get_sessions(self) -> List[SessionSummary]:
try: try:
sessions = self.app.core.client.get_sessions() sessions = self.app.core.client.get_sessions()
logging.info("sessions: %s", sessions) logger.info("sessions: %s", sessions)
return sorted(sessions, key=lambda x: x.id) return sorted(sessions, key=lambda x: x.id)
except grpc.RpcError as e: except grpc.RpcError as e:
self.app.show_grpc_exception("Get Sessions Error", e) self.app.show_grpc_exception("Get Sessions Error", e)
@ -175,7 +177,7 @@ class SessionsDialog(Dialog):
self.selected_id = None self.selected_id = None
self.delete_button.config(state=tk.DISABLED) self.delete_button.config(state=tk.DISABLED)
self.connect_button.config(state=tk.DISABLED) self.connect_button.config(state=tk.DISABLED)
logging.debug("selected session: %s", self.selected_session) logger.debug("selected session: %s", self.selected_session)
def click_connect(self) -> None: def click_connect(self) -> None:
if not self.selected_session: if not self.selected_session:
@ -199,7 +201,7 @@ class SessionsDialog(Dialog):
def click_delete(self) -> None: def click_delete(self) -> None:
if not self.selected_session: if not self.selected_session:
return return
logging.info("click delete session: %s", self.selected_session) logger.info("click delete session: %s", self.selected_session)
self.tree.delete(self.selected_id) self.tree.delete(self.selected_id)
self.app.core.delete_session(self.selected_session) self.app.core.delete_session(self.selected_session)
session_id = None session_id = None

8
daemon/core/gui/graph/edges.py
View file

@ -11,6 +11,8 @@ from core.gui.frames.link import EdgeInfoFrame, WirelessEdgeInfoFrame
from core.gui.graph import tags from core.gui.graph import tags
from core.gui.utils import bandwidth_text, delay_jitter_text from core.gui.utils import bandwidth_text, delay_jitter_text
logger = logging.getLogger(__name__)
if TYPE_CHECKING: if TYPE_CHECKING:
from core.gui.app import Application from core.gui.app import Application
from core.gui.graph.graph import CanvasGraph from core.gui.graph.graph import CanvasGraph
@ -393,7 +395,7 @@ class Edge:
self.dst.canvas.coords(self.dst_label2, *dst_pos) self.dst.canvas.coords(self.dst_label2, *dst_pos)
def delete(self) -> None: def delete(self) -> None:
logging.debug("deleting canvas edge, id: %s", self.id) logger.debug("deleting canvas edge, id: %s", self.id)
self.src.canvas.delete(self.id) self.src.canvas.delete(self.id)
self.src.canvas.delete(self.src_label) self.src.canvas.delete(self.src_label)
self.src.canvas.delete(self.dst_label) self.src.canvas.delete(self.dst_label)
@ -488,7 +490,7 @@ class CanvasWirelessEdge(Edge):
token: str, token: str,
link: Link, link: Link,
) -> None: ) -> None:
logging.debug("drawing wireless link from node %s to node %s", src, dst) logger.debug("drawing wireless link from node %s to node %s", src, dst)
super().__init__(app, src, dst) super().__init__(app, src, dst)
self.src.wireless_edges.add(self) self.src.wireless_edges.add(self)
self.dst.wireless_edges.add(self) self.dst.wireless_edges.add(self)
@ -622,7 +624,7 @@ class CanvasEdge(Edge):
self.draw_link_options() self.draw_link_options()
def complete(self, dst: "CanvasNode", link: Link = None) -> None: def complete(self, dst: "CanvasNode", link: Link = None) -> None:
logging.debug( logger.debug(
"completing wired link from node(%s) to node(%s)", "completing wired link from node(%s) to node(%s)",
self.src.core_node.name, self.src.core_node.name,
dst.core_node.name, dst.core_node.name,

46
daemon/core/gui/graph/graph.py
View file

@ -18,6 +18,8 @@ from core.gui.graph.node import CanvasNode, ShadowNode
from core.gui.graph.shape import Shape from core.gui.graph.shape import Shape
from core.gui.graph.shapeutils import ShapeType, is_draw_shape, is_marker from core.gui.graph.shapeutils import ShapeType, is_draw_shape, is_marker
logger = logging.getLogger(__name__)
if TYPE_CHECKING: if TYPE_CHECKING:
from core.gui.app import Application from core.gui.app import Application
from core.gui.graph.manager import CanvasManager from core.gui.graph.manager import CanvasManager
@ -184,7 +186,7 @@ class CanvasGraph(tk.Canvas):
""" """
Draw a node or finish drawing an edge according to the current graph mode Draw a node or finish drawing an edge according to the current graph mode
""" """
logging.debug("click release") logger.debug("click release")
x, y = self.canvas_xy(event) x, y = self.canvas_xy(event)
if not self.inside_canvas(x, y): if not self.inside_canvas(x, y):
return return
@ -210,7 +212,7 @@ class CanvasGraph(tk.Canvas):
else: else:
self.focus_set() self.focus_set()
self.selected = self.get_selected(event) self.selected = self.get_selected(event)
logging.debug( logger.debug(
"click release selected(%s) mode(%s)", self.selected, self.manager.mode "click release selected(%s) mode(%s)", self.selected, self.manager.mode
) )
if self.manager.mode == GraphMode.EDGE: if self.manager.mode == GraphMode.EDGE:
@ -228,7 +230,7 @@ class CanvasGraph(tk.Canvas):
edge = self.drawing_edge edge = self.drawing_edge
self.drawing_edge = None self.drawing_edge = None
# edge dst must be a node # edge dst must be a node
logging.debug("current selected: %s", self.selected) logger.debug("current selected: %s", self.selected)
dst_node = self.nodes.get(self.selected) dst_node = self.nodes.get(self.selected)
if not dst_node: if not dst_node:
edge.delete() edge.delete()
@ -331,8 +333,8 @@ class CanvasGraph(tk.Canvas):
self.offset[0] * factor + event.x * (1 - factor), self.offset[0] * factor + event.x * (1 - factor),
self.offset[1] * factor + event.y * (1 - factor), self.offset[1] * factor + event.y * (1 - factor),
) )
logging.debug("ratio: %s", self.ratio) logger.debug("ratio: %s", self.ratio)
logging.debug("offset: %s", self.offset) logger.debug("offset: %s", self.offset)
self.app.statusbar.set_zoom(self.ratio) self.app.statusbar.set_zoom(self.ratio)
if self.wallpaper: if self.wallpaper:
self.redraw_wallpaper() self.redraw_wallpaper()
@ -347,10 +349,10 @@ class CanvasGraph(tk.Canvas):
self.cursor = x, y self.cursor = x, y
selected = self.get_selected(event) selected = self.get_selected(event)
logging.debug("click press(%s): %s", self.cursor, selected) logger.debug("click press(%s): %s", self.cursor, selected)
x_check = self.cursor[0] - self.offset[0] x_check = self.cursor[0] - self.offset[0]
y_check = self.cursor[1] - self.offset[1] y_check = self.cursor[1] - self.offset[1]
logging.debug("click press offset(%s, %s)", x_check, y_check) logger.debug("click press offset(%s, %s)", x_check, y_check)
is_node = selected in self.nodes is_node = selected in self.nodes
if self.manager.mode == GraphMode.EDGE and is_node: if self.manager.mode == GraphMode.EDGE and is_node:
node = self.nodes[selected] node = self.nodes[selected]
@ -387,7 +389,7 @@ class CanvasGraph(tk.Canvas):
node = self.nodes[selected] node = self.nodes[selected]
self.select_object(node.id) self.select_object(node.id)
self.selected = selected self.selected = selected
logging.debug( logger.debug(
"selected node(%s), coords: (%s, %s)", "selected node(%s), coords: (%s, %s)",
node.core_node.name, node.core_node.name,
node.core_node.position.x, node.core_node.position.x,
@ -397,7 +399,7 @@ class CanvasGraph(tk.Canvas):
shadow_node = self.shadow_nodes[selected] shadow_node = self.shadow_nodes[selected]
self.select_object(shadow_node.id) self.select_object(shadow_node.id)
self.selected = selected self.selected = selected
logging.debug( logger.debug(
"selected shadow node(%s), coords: (%s, %s)", "selected shadow node(%s), coords: (%s, %s)",
shadow_node.node.core_node.name, shadow_node.node.core_node.name,
shadow_node.node.core_node.position.x, shadow_node.node.core_node.position.x,
@ -418,7 +420,7 @@ class CanvasGraph(tk.Canvas):
self.cursor = x, y self.cursor = x, y
# handle multiple selections # handle multiple selections
logging.debug("control left click: %s", event) logger.debug("control left click: %s", event)
selected = self.get_selected(event) selected = self.get_selected(event)
if ( if (
selected not in self.selection selected not in self.selection
@ -489,12 +491,12 @@ class CanvasGraph(tk.Canvas):
""" """
delete selected nodes and any data that relates to it delete selected nodes and any data that relates to it
""" """
logging.debug("press delete key") logger.debug("press delete key")
if not self.app.core.is_runtime(): if not self.app.core.is_runtime():
self.delete_selected_objects() self.delete_selected_objects()
self.app.default_info() self.app.default_info()
else: else:
logging.debug("node deletion is disabled during runtime state") logger.debug("node deletion is disabled during runtime state")
def double_click(self, event: tk.Event) -> None: def double_click(self, event: tk.Event) -> None:
selected = self.get_selected(event) selected = self.get_selected(event)
@ -606,10 +608,10 @@ class CanvasGraph(tk.Canvas):
self.draw_wallpaper(image) self.draw_wallpaper(image)
def redraw_canvas(self, dimensions: Tuple[int, int] = None) -> None: def redraw_canvas(self, dimensions: Tuple[int, int] = None) -> None:
logging.debug("redrawing canvas to dimensions: %s", dimensions) logger.debug("redrawing canvas to dimensions: %s", dimensions)
# reset scale and move back to original position # reset scale and move back to original position
logging.debug("resetting scaling: %s %s", self.ratio, self.offset) logger.debug("resetting scaling: %s %s", self.ratio, self.offset)
factor = 1 / self.ratio factor = 1 / self.ratio
self.scale(tk.ALL, self.offset[0], self.offset[1], factor, factor) self.scale(tk.ALL, self.offset[0], self.offset[1], factor, factor)
self.move(tk.ALL, -self.offset[0], -self.offset[1]) self.move(tk.ALL, -self.offset[0], -self.offset[1])
@ -628,11 +630,11 @@ class CanvasGraph(tk.Canvas):
def redraw_wallpaper(self) -> None: def redraw_wallpaper(self) -> None:
if self.adjust_to_dim.get(): if self.adjust_to_dim.get():
logging.debug("drawing wallpaper to canvas dimensions") logger.debug("drawing wallpaper to canvas dimensions")
self.resize_to_wallpaper() self.resize_to_wallpaper()
else: else:
option = ScaleOption(self.scale_option.get()) option = ScaleOption(self.scale_option.get())
logging.debug("drawing canvas using scaling option: %s", option) logger.debug("drawing canvas using scaling option: %s", option)
if option == ScaleOption.UPPER_LEFT: if option == ScaleOption.UPPER_LEFT:
self.wallpaper_upper_left() self.wallpaper_upper_left()
elif option == ScaleOption.CENTERED: elif option == ScaleOption.CENTERED:
@ -640,7 +642,7 @@ class CanvasGraph(tk.Canvas):
elif option == ScaleOption.SCALED: elif option == ScaleOption.SCALED:
self.wallpaper_scaled() self.wallpaper_scaled()
elif option == ScaleOption.TILED: elif option == ScaleOption.TILED:
logging.warning("tiled background not implemented yet") logger.warning("tiled background not implemented yet")
self.organize() self.organize()
def organize(self) -> None: def organize(self) -> None:
@ -648,7 +650,7 @@ class CanvasGraph(tk.Canvas):
self.tag_raise(tag) self.tag_raise(tag)
def set_wallpaper(self, filename: Optional[str]) -> None: def set_wallpaper(self, filename: Optional[str]) -> None:
logging.info("setting canvas(%s) background: %s", self.id, filename) logger.info("setting canvas(%s) background: %s", self.id, filename)
if filename: if filename:
img = Image.open(filename) img = Image.open(filename)
self.wallpaper = img self.wallpaper = img
@ -673,10 +675,10 @@ class CanvasGraph(tk.Canvas):
def copy(self) -> None: def copy(self) -> None:
if self.core.is_runtime(): if self.core.is_runtime():
logging.debug("copy is disabled during runtime state") logger.debug("copy is disabled during runtime state")
return return
if self.selection: if self.selection:
logging.debug("to copy nodes: %s", self.selection) logger.debug("to copy nodes: %s", self.selection)
self.to_copy.clear() self.to_copy.clear()
for node_id in self.selection.keys(): for node_id in self.selection.keys():
canvas_node = self.nodes[node_id] canvas_node = self.nodes[node_id]
@ -684,7 +686,7 @@ class CanvasGraph(tk.Canvas):
def paste(self) -> None: def paste(self) -> None:
if self.core.is_runtime(): if self.core.is_runtime():
logging.debug("paste is disabled during runtime state") logger.debug("paste is disabled during runtime state")
return return
# maps original node canvas id to copy node canvas id # maps original node canvas id to copy node canvas id
copy_map = {} copy_map = {}
@ -825,7 +827,7 @@ class CanvasGraph(tk.Canvas):
wallpaper = Path(wallpaper) wallpaper = Path(wallpaper)
if not wallpaper.is_file(): if not wallpaper.is_file():
wallpaper = appconfig.BACKGROUNDS_PATH.joinpath(wallpaper) wallpaper = appconfig.BACKGROUNDS_PATH.joinpath(wallpaper)
logging.info("canvas(%s), wallpaper: %s", self.id, wallpaper) logger.info("canvas(%s), wallpaper: %s", self.id, wallpaper)
if wallpaper.is_file(): if wallpaper.is_file():
self.set_wallpaper(str(wallpaper)) self.set_wallpaper(str(wallpaper))
else: else:

12
daemon/core/gui/graph/manager.py
View file

@ -19,6 +19,8 @@ from core.gui.graph.node import CanvasNode
from core.gui.graph.shapeutils import ShapeType from core.gui.graph.shapeutils import ShapeType
from core.gui.nodeutils import NodeDraw from core.gui.nodeutils import NodeDraw
logger = logging.getLogger(__name__)
if TYPE_CHECKING: if TYPE_CHECKING:
from core.gui.app import Application from core.gui.app import Application
from core.gui.coreclient import CoreClient from core.gui.coreclient import CoreClient
@ -166,7 +168,7 @@ class CanvasManager:
canvas_id = self._next_id() canvas_id = self._next_id()
self.notebook.add(tab, text=f"Canvas {canvas_id}") self.notebook.add(tab, text=f"Canvas {canvas_id}")
unique_id = self.notebook.tabs()[-1] unique_id = self.notebook.tabs()[-1]
logging.info("creating canvas(%s)", canvas_id) logger.info("creating canvas(%s)", canvas_id)
self.canvas_ids[unique_id] = canvas_id self.canvas_ids[unique_id] = canvas_id
self.unique_ids[canvas_id] = unique_id self.unique_ids[canvas_id] = unique_id
@ -213,7 +215,7 @@ class CanvasManager:
self.unique_ids.clear() self.unique_ids.clear()
self.edges.clear() self.edges.clear()
self.wireless_edges.clear() self.wireless_edges.clear()
logging.info("cleared canvases") logger.info("cleared canvases")
# reset settings # reset settings
self.show_node_labels.set(True) self.show_node_labels.set(True)
@ -289,7 +291,7 @@ class CanvasManager:
for canvas_config in config.get("canvases", []): for canvas_config in config.get("canvases", []):
canvas_id = canvas_config.get("id") canvas_id = canvas_config.get("id")
if canvas_id is None: if canvas_id is None:
logging.error("canvas config id not provided") logger.error("canvas config id not provided")
continue continue
canvas = self.get(canvas_id) canvas = self.get(canvas_id)
canvas.parse_metadata(canvas_config) canvas.parse_metadata(canvas_config)
@ -297,7 +299,7 @@ class CanvasManager:
def add_core_node(self, core_node: Node) -> None: def add_core_node(self, core_node: Node) -> None:
# get canvas tab for node # get canvas tab for node
canvas_id = core_node.canvas if core_node.canvas > 0 else 1 canvas_id = core_node.canvas if core_node.canvas > 0 else 1
logging.info("adding core node canvas(%s): %s", core_node.name, canvas_id) logger.info("adding core node canvas(%s): %s", core_node.name, canvas_id)
canvas = self.get(canvas_id) canvas = self.get(canvas_id)
image = nutils.get_icon(core_node, self.app) image = nutils.get_icon(core_node, self.app)
x = core_node.position.x x = core_node.position.x
@ -354,7 +356,7 @@ class CanvasManager:
network_id = link.network_id if link.network_id else None network_id = link.network_id if link.network_id else None
token = create_wireless_token(src.id, dst.id, network_id) token = create_wireless_token(src.id, dst.id, network_id)
if token in self.wireless_edges: if token in self.wireless_edges:
logging.warning("ignoring link that already exists: %s", link) logger.warning("ignoring link that already exists: %s", link)
return return
edge = CanvasWirelessEdge(self.app, src, dst, network_id, token, link) edge = CanvasWirelessEdge(self.app, src, dst, network_id, token, link)
self.wireless_edges[token] = edge self.wireless_edges[token] = edge

10
daemon/core/gui/graph/node.py
View file

@ -24,6 +24,8 @@ from core.gui.graph.edges import CanvasEdge, CanvasWirelessEdge
from core.gui.graph.tooltip import CanvasTooltip from core.gui.graph.tooltip import CanvasTooltip
from core.gui.images import ImageEnum from core.gui.images import ImageEnum
logger = logging.getLogger(__name__)
if TYPE_CHECKING: if TYPE_CHECKING:
from core.gui.app import Application from core.gui.app import Application
from core.gui.graph.graph import CanvasGraph from core.gui.graph.graph import CanvasGraph
@ -87,7 +89,7 @@ class CanvasNode:
self.canvas.tag_bind(self.id, "<Button-1>", self.show_info) self.canvas.tag_bind(self.id, "<Button-1>", self.show_info)
def delete(self) -> None: def delete(self) -> None:
logging.debug("Delete canvas node for %s", self.core_node) logger.debug("Delete canvas node for %s", self.core_node)
self.canvas.delete(self.id) self.canvas.delete(self.id)
self.canvas.delete(self.text_id) self.canvas.delete(self.text_id)
self.delete_antennas() self.delete_antennas()
@ -110,7 +112,7 @@ class CanvasNode:
""" """
delete one antenna delete one antenna
""" """
logging.debug("Delete an antenna on %s", self.core_node.name) logger.debug("Delete an antenna on %s", self.core_node.name)
if self.antennas: if self.antennas:
antenna_id = self.antennas.pop() antenna_id = self.antennas.pop()
self.canvas.delete(antenna_id) self.canvas.delete(antenna_id)
@ -120,7 +122,7 @@ class CanvasNode:
""" """
delete all antennas delete all antennas
""" """
logging.debug("Remove all antennas for %s", self.core_node.name) logger.debug("Remove all antennas for %s", self.core_node.name)
for antenna_id in self.antennas: for antenna_id in self.antennas:
self.canvas.delete(antenna_id) self.canvas.delete(antenna_id)
self.antennas.clear() self.antennas.clear()
@ -400,7 +402,7 @@ class CanvasNode:
def update_icon(self, icon_path: str) -> None: def update_icon(self, icon_path: str) -> None:
if not Path(icon_path).exists(): if not Path(icon_path).exists():
logging.error(f"node icon does not exist: {icon_path}") logger.error(f"node icon does not exist: {icon_path}")
return return
self.core_node.icon = icon_path self.core_node.icon = icon_path
self.image = images.from_file(icon_path, width=images.NODE_SIZE) self.image = images.from_file(icon_path, width=images.NODE_SIZE)

8
daemon/core/gui/graph/shape.py
View file

@ -5,6 +5,8 @@ from core.gui.dialogs.shapemod import ShapeDialog
from core.gui.graph import tags from core.gui.graph import tags
from core.gui.graph.shapeutils import ShapeType from core.gui.graph.shapeutils import ShapeType
logger = logging.getLogger(__name__)
if TYPE_CHECKING: if TYPE_CHECKING:
from core.gui.app import Application from core.gui.app import Application
from core.gui.graph.graph import CanvasGraph from core.gui.graph.graph import CanvasGraph
@ -92,7 +94,7 @@ class Shape:
shape = Shape(app, canvas, shape_type, *coords, data=data) shape = Shape(app, canvas, shape_type, *coords, data=data)
canvas.shapes[shape.id] = shape canvas.shapes[shape.id] = shape
except ValueError: except ValueError:
logging.exception("unknown shape: %s", shape_type) logger.exception("unknown shape: %s", shape_type)
def draw(self) -> None: def draw(self) -> None:
if self.created: if self.created:
@ -139,7 +141,7 @@ class Shape:
state=self.app.manager.show_annotations.state(), state=self.app.manager.show_annotations.state(),
) )
else: else:
logging.error("unknown shape type: %s", self.shape_type) logger.error("unknown shape type: %s", self.shape_type)
self.created = True self.created = True
def get_font(self) -> List[Union[int, str]]: def get_font(self) -> List[Union[int, str]]:
@ -192,7 +194,7 @@ class Shape:
self.canvas.move(self.text_id, x_offset, y_offset) self.canvas.move(self.text_id, x_offset, y_offset)
def delete(self) -> None: def delete(self) -> None:
logging.debug("Delete shape, id(%s)", self.id) logger.debug("Delete shape, id(%s)", self.id)
self.canvas.delete(self.id) self.canvas.delete(self.id)
self.canvas.delete(self.text_id) self.canvas.delete(self.text_id)

12
daemon/core/gui/interface.py
View file

@ -9,6 +9,8 @@ from core.gui import nodeutils as nutils
from core.gui.graph.edges import CanvasEdge from core.gui.graph.edges import CanvasEdge
from core.gui.graph.node import CanvasNode from core.gui.graph.node import CanvasNode
logger = logging.getLogger(__name__)
if TYPE_CHECKING: if TYPE_CHECKING:
from core.gui.app import Application from core.gui.app import Application
@ -196,12 +198,12 @@ class InterfaceManager:
else: else:
self.current_subnets = self.next_subnets() self.current_subnets = self.next_subnets()
else: else:
logging.info("ignoring subnet change for link between network nodes") logger.info("ignoring subnet change for link between network nodes")
def find_subnets( def find_subnets(
self, canvas_node: CanvasNode, visited: Set[int] = None self, canvas_node: CanvasNode, visited: Set[int] = None
) -> Optional[IPNetwork]: ) -> Optional[IPNetwork]:
logging.info("finding subnet for node: %s", canvas_node.core_node.name) logger.info("finding subnet for node: %s", canvas_node.core_node.name)
subnets = None subnets = None
if not visited: if not visited:
visited = set() visited = set()
@ -220,7 +222,7 @@ class InterfaceManager:
else: else:
subnets = self.find_subnets(check_node, visited) subnets = self.find_subnets(check_node, visited)
if subnets: if subnets:
logging.info("found subnets: %s", subnets) logger.info("found subnets: %s", subnets)
break break
return subnets return subnets
@ -244,7 +246,7 @@ class InterfaceManager:
iface1=src_iface, iface1=src_iface,
iface2=dst_iface, iface2=dst_iface,
) )
logging.info("added link between %s and %s", src_node.name, dst_node.name) logger.info("added link between %s and %s", src_node.name, dst_node.name)
return link return link
def create_iface(self, canvas_node: CanvasNode, wireless_link: bool) -> Interface: def create_iface(self, canvas_node: CanvasNode, wireless_link: bool) -> Interface:
@ -266,5 +268,5 @@ class InterfaceManager:
ip6=ip6, ip6=ip6,
ip6_mask=ip6_mask, ip6_mask=ip6_mask,
) )
logging.info("create node(%s) interface(%s)", node.name, iface) logger.info("create node(%s) interface(%s)", node.name, iface)
return iface return iface

16
daemon/core/gui/menubar.py
View file

@ -27,6 +27,8 @@ from core.gui.graph.manager import CanvasManager
from core.gui.observers import ObserversMenu from core.gui.observers import ObserversMenu
from core.gui.task import ProgressTask from core.gui.task import ProgressTask
logger = logging.getLogger(__name__)
if TYPE_CHECKING: if TYPE_CHECKING:
from core.gui.app import Application from core.gui.app import Application
@ -274,10 +276,10 @@ class Menubar(tk.Menu):
def open_recent_files(self, file_path: Path) -> None: def open_recent_files(self, file_path: Path) -> None:
if file_path.is_file(): if file_path.is_file():
logging.debug("Open recent file %s", file_path) logger.debug("Open recent file %s", file_path)
self.open_xml_task(file_path) self.open_xml_task(file_path)
else: else:
logging.warning("File does not exist %s", file_path) logger.warning("File does not exist %s", file_path)
def update_recent_files(self) -> None: def update_recent_files(self) -> None:
self.recent_menu.delete(0, tk.END) self.recent_menu.delete(0, tk.END)
@ -429,23 +431,23 @@ class Menubar(tk.Menu):
canvas.show_hidden() canvas.show_hidden()
def click_session_options(self) -> None: def click_session_options(self) -> None:
logging.debug("Click options") logger.debug("Click options")
dialog = SessionOptionsDialog(self.app) dialog = SessionOptionsDialog(self.app)
if not dialog.has_error: if not dialog.has_error:
dialog.show() dialog.show()
def click_sessions(self) -> None: def click_sessions(self) -> None:
logging.debug("Click change sessions") logger.debug("Click change sessions")
dialog = SessionsDialog(self.app) dialog = SessionsDialog(self.app)
dialog.show() dialog.show()
def click_hooks(self) -> None: def click_hooks(self) -> None:
logging.debug("Click hooks") logger.debug("Click hooks")
dialog = HooksDialog(self.app) dialog = HooksDialog(self.app)
dialog.show() dialog.show()
def click_servers(self) -> None: def click_servers(self) -> None:
logging.debug("Click emulation servers") logger.debug("Click emulation servers")
dialog = ServersDialog(self.app) dialog = ServersDialog(self.app)
dialog.show() dialog.show()
@ -458,7 +460,7 @@ class Menubar(tk.Menu):
padding = (images.NODE_SIZE / 2) + 10 padding = (images.NODE_SIZE / 2) + 10
layout_size = padding + images.NODE_SIZE layout_size = padding + images.NODE_SIZE
col_count = width // layout_size col_count = width // layout_size
logging.info( logger.info(
"auto grid layout: dimension(%s, %s) col(%s)", width, height, col_count "auto grid layout: dimension(%s, %s) col(%s)", width, height, col_count
) )
canvas = self.manager.current() canvas = self.manager.current()

6
daemon/core/gui/nodeutils.py
View file

@ -8,6 +8,8 @@ from core.gui import images
from core.gui.appconfig import CustomNode, GuiConfig from core.gui.appconfig import CustomNode, GuiConfig
from core.gui.images import ImageEnum from core.gui.images import ImageEnum
logger = logging.getLogger(__name__)
if TYPE_CHECKING: if TYPE_CHECKING:
from core.gui.app import Application from core.gui.app import Application
@ -118,11 +120,11 @@ def get_icon(node: Node, app: "Application") -> PhotoImage:
try: try:
image = images.from_file(node.icon, width=images.NODE_SIZE, scale=scale) image = images.from_file(node.icon, width=images.NODE_SIZE, scale=scale)
except OSError: except OSError:
logging.error("invalid icon: %s", node.icon) logger.error("invalid icon: %s", node.icon)
# custom node # custom node
elif is_custom(node): elif is_custom(node):
image_file = _get_custom_file(app.guiconfig, node.model) image_file = _get_custom_file(app.guiconfig, node.model)
logging.info("custom node file: %s", image_file) logger.info("custom node file: %s", image_file)
if image_file: if image_file:
image = images.from_file(image_file, width=images.NODE_SIZE, scale=scale) image = images.from_file(image_file, width=images.NODE_SIZE, scale=scale)
# built in node # built in node

4
daemon/core/gui/task.py
View file

@ -4,6 +4,8 @@ import time
import tkinter as tk import tkinter as tk
from typing import TYPE_CHECKING, Any, Callable, Optional, Tuple from typing import TYPE_CHECKING, Any, Callable, Optional, Tuple
logger = logging.getLogger(__name__)
if TYPE_CHECKING: if TYPE_CHECKING:
from core.gui.app import Application from core.gui.app import Application
@ -43,7 +45,7 @@ class ProgressTask:
if self.callback: if self.callback:
self.app.after(0, self.callback, *values) self.app.after(0, self.callback, *values)
except Exception as e: except Exception as e:
logging.exception("progress task exception") logger.exception("progress task exception")
self.app.show_exception("Task Error", e) self.app.show_exception("Task Error", e)
finally: finally:
self.app.after(0, self.complete) self.app.after(0, self.complete)

10
daemon/core/gui/toolbar.py
View file

@ -20,6 +20,8 @@ from core.gui.task import ProgressTask
from core.gui.themes import Styles from core.gui.themes import Styles
from core.gui.tooltip import Tooltip from core.gui.tooltip import Tooltip
logger = logging.getLogger(__name__)
if TYPE_CHECKING: if TYPE_CHECKING:
from core.gui.app import Application from core.gui.app import Application
@ -338,7 +340,7 @@ class Toolbar(ttk.Frame):
type_enum: NodeTypeEnum, type_enum: NodeTypeEnum,
image: PhotoImage, image: PhotoImage,
) -> None: ) -> None:
logging.debug("update button(%s): %s", button, node_draw) logger.debug("update button(%s): %s", button, node_draw)
button.configure(image=image) button.configure(image=image)
button.image = image button.image = image
self.app.manager.node_draw = node_draw self.app.manager.node_draw = node_draw
@ -399,7 +401,7 @@ class Toolbar(ttk.Frame):
""" """
redraw buttons on the toolbar, send node and link messages to grpc server redraw buttons on the toolbar, send node and link messages to grpc server
""" """
logging.info("clicked stop button") logger.info("clicked stop button")
self.app.menubar.set_state(is_runtime=False) self.app.menubar.set_state(is_runtime=False)
self.app.core.close_mobility_players() self.app.core.close_mobility_players()
enable_buttons(self.runtime_frame, enabled=False) enable_buttons(self.runtime_frame, enabled=False)
@ -415,7 +417,7 @@ class Toolbar(ttk.Frame):
def update_annotation( def update_annotation(
self, shape_type: ShapeType, image_enum: ImageEnum, image: PhotoImage self, shape_type: ShapeType, image_enum: ImageEnum, image: PhotoImage
) -> None: ) -> None:
logging.debug("clicked annotation") logger.debug("clicked annotation")
self.annotation_button.configure(image=image) self.annotation_button.configure(image=image)
self.annotation_button.image = image self.annotation_button.image = image
self.app.manager.annotation_type = shape_type self.app.manager.annotation_type = shape_type
@ -433,7 +435,7 @@ class Toolbar(ttk.Frame):
self.marker_frame.grid() self.marker_frame.grid()
def click_run_button(self) -> None: def click_run_button(self) -> None:
logging.debug("Click on RUN button") logger.debug("Click on RUN button")
dialog = RunToolDialog(self.app) dialog = RunToolDialog(self.app)
dialog.show() dialog.show()

4
daemon/core/gui/widgets.py
View file

@ -10,6 +10,8 @@ from core.gui import appconfig, themes, validation
from core.gui.dialogs.dialog import Dialog from core.gui.dialogs.dialog import Dialog
from core.gui.themes import FRAME_PAD, PADX, PADY from core.gui.themes import FRAME_PAD, PADX, PADY
logger = logging.getLogger(__name__)
if TYPE_CHECKING: if TYPE_CHECKING:
from core.gui.app import Application from core.gui.app import Application
@ -161,7 +163,7 @@ class ConfigFrame(ttk.Notebook):
) )
entry.grid(row=index, column=1, sticky=tk.EW) entry.grid(row=index, column=1, sticky=tk.EW)
else: else:
logging.error("unhandled config option type: %s", option.type) logger.error("unhandled config option type: %s", option.type)
self.values[option.name] = value self.values[option.name] = value
def parse_config(self) -> Dict[str, str]: def parse_config(self) -> Dict[str, str]:

9
daemon/core/location/geo.py
View file

@ -10,6 +10,7 @@ from pyproj import Transformer
from core.emulator.enumerations import RegisterTlvs from core.emulator.enumerations import RegisterTlvs
logger = logging.getLogger(__name__)
SCALE_FACTOR: float = 100.0 SCALE_FACTOR: float = 100.0
CRS_WGS84: int = 4326 CRS_WGS84: int = 4326
CRS_PROJ: int = 3857 CRS_PROJ: int = 3857
@ -92,7 +93,7 @@ class GeoLocation:
:param alt: altitude value :param alt: altitude value
:return: x,y,z representation of provided values :return: x,y,z representation of provided values
""" """
logging.debug("input lon,lat,alt(%s, %s, %s)", lon, lat, alt) logger.debug("input lon,lat,alt(%s, %s, %s)", lon, lat, alt)
px, py = self.to_pixels.transform(lon, lat) px, py = self.to_pixels.transform(lon, lat)
px -= self.refproj[0] px -= self.refproj[0]
py -= self.refproj[1] py -= self.refproj[1]
@ -100,7 +101,7 @@ class GeoLocation:
x = self.meters2pixels(px) + self.refxyz[0] x = self.meters2pixels(px) + self.refxyz[0]
y = -(self.meters2pixels(py) + self.refxyz[1]) y = -(self.meters2pixels(py) + self.refxyz[1])
z = self.meters2pixels(pz) + self.refxyz[2] z = self.meters2pixels(pz) + self.refxyz[2]
logging.debug("result x,y,z(%s, %s, %s)", x, y, z) logger.debug("result x,y,z(%s, %s, %s)", x, y, z)
return x, y, z return x, y, z
def getgeo(self, x: float, y: float, z: float) -> Tuple[float, float, float]: def getgeo(self, x: float, y: float, z: float) -> Tuple[float, float, float]:
@ -112,7 +113,7 @@ class GeoLocation:
:param z: z value :param z: z value
:return: lat,lon,alt representation of provided values :return: lat,lon,alt representation of provided values
""" """
logging.debug("input x,y(%s, %s)", x, y) logger.debug("input x,y(%s, %s)", x, y)
x -= self.refxyz[0] x -= self.refxyz[0]
y = -(y - self.refxyz[1]) y = -(y - self.refxyz[1])
if z is None: if z is None:
@ -123,5 +124,5 @@ class GeoLocation:
py = self.refproj[1] + self.pixels2meters(y) py = self.refproj[1] + self.pixels2meters(y)
lon, lat = self.to_geo.transform(px, py) lon, lat = self.to_geo.transform(px, py)
alt = self.refgeo[2] + self.pixels2meters(z) alt = self.refgeo[2] + self.pixels2meters(z)
logging.debug("result lon,lat,alt(%s, %s, %s)", lon, lat, alt) logger.debug("result lon,lat,alt(%s, %s, %s)", lon, lat, alt)
return lat, lon, alt return lat, lon, alt

46
daemon/core/location/mobility.py
View file

@ -28,6 +28,8 @@ from core.nodes.base import CoreNode
from core.nodes.interface import CoreInterface from core.nodes.interface import CoreInterface
from core.nodes.network import WlanNode from core.nodes.network import WlanNode
logger = logging.getLogger(__name__)
if TYPE_CHECKING: if TYPE_CHECKING:
from core.emulator.session import Session from core.emulator.session import Session
@ -81,7 +83,7 @@ class MobilityManager(ModelManager):
if node_ids is None: if node_ids is None:
node_ids = self.nodes() node_ids = self.nodes()
for node_id in node_ids: for node_id in node_ids:
logging.debug( logger.debug(
"node(%s) mobility startup: %s", node_id, self.get_all_configs(node_id) "node(%s) mobility startup: %s", node_id, self.get_all_configs(node_id)
) )
try: try:
@ -95,8 +97,8 @@ class MobilityManager(ModelManager):
if node.mobility: if node.mobility:
self.session.event_loop.add_event(0.0, node.mobility.startup) self.session.event_loop.add_event(0.0, node.mobility.startup)
except CoreError: except CoreError:
logging.exception("mobility startup error") logger.exception("mobility startup error")
logging.warning( logger.warning(
"skipping mobility configuration for unknown node: %s", node_id "skipping mobility configuration for unknown node: %s", node_id
) )
@ -114,7 +116,7 @@ class MobilityManager(ModelManager):
try: try:
node = get_mobility_node(self.session, node_id) node = get_mobility_node(self.session, node_id)
except CoreError: except CoreError:
logging.exception( logger.exception(
"ignoring event for model(%s), unknown node(%s)", name, node_id "ignoring event for model(%s), unknown node(%s)", name, node_id
) )
return return
@ -124,17 +126,17 @@ class MobilityManager(ModelManager):
for model in models: for model in models:
cls = self.models.get(model) cls = self.models.get(model)
if not cls: if not cls:
logging.warning("ignoring event for unknown model '%s'", model) logger.warning("ignoring event for unknown model '%s'", model)
continue continue
if cls.config_type in [RegisterTlvs.WIRELESS, RegisterTlvs.MOBILITY]: if cls.config_type in [RegisterTlvs.WIRELESS, RegisterTlvs.MOBILITY]:
model = node.mobility model = node.mobility
else: else:
continue continue
if model is None: if model is None:
logging.warning("ignoring event, %s has no model", node.name) logger.warning("ignoring event, %s has no model", node.name)
continue continue
if cls.name != model.name: if cls.name != model.name:
logging.warning( logger.warning(
"ignoring event for %s wrong model %s,%s", "ignoring event for %s wrong model %s,%s",
node.name, node.name,
cls.name, cls.name,
@ -410,16 +412,16 @@ class BasicRangeModel(WirelessModel):
linked = self.wlan.linked(a, b) linked = self.wlan.linked(a, b)
if d > self.range: if d > self.range:
if linked: if linked:
logging.debug("was linked, unlinking") logger.debug("was linked, unlinking")
self.wlan.unlink(a, b) self.wlan.unlink(a, b)
self.sendlinkmsg(a, b, unlink=True) self.sendlinkmsg(a, b, unlink=True)
else: else:
if not linked: if not linked:
logging.debug("was not linked, linking") logger.debug("was not linked, linking")
self.wlan.link(a, b) self.wlan.link(a, b)
self.sendlinkmsg(a, b) self.sendlinkmsg(a, b)
except KeyError: except KeyError:
logging.exception("error getting interfaces during calclink") logger.exception("error getting interfaces during calclink")
@staticmethod @staticmethod
def calcdistance( def calcdistance(
@ -449,7 +451,7 @@ class BasicRangeModel(WirelessModel):
self.range = self._get_config(self.range, config, "range") self.range = self._get_config(self.range, config, "range")
if self.range is None: if self.range is None:
self.range = 0 self.range = 0
logging.debug("wlan %s set range to %s", self.wlan.name, self.range) logger.debug("wlan %s set range to %s", self.wlan.name, self.range)
self.bw = self._get_config(self.bw, config, "bandwidth") self.bw = self._get_config(self.bw, config, "bandwidth")
self.delay = self._get_config(self.delay, config, "delay") self.delay = self._get_config(self.delay, config, "delay")
self.loss = self._get_config(self.loss, config, "error") self.loss = self._get_config(self.loss, config, "error")
@ -927,7 +929,7 @@ class Ns2ScriptedMobility(WayPointMobility):
def update_config(self, config: Dict[str, str]) -> None: def update_config(self, config: Dict[str, str]) -> None:
self.file = Path(config["file"]) self.file = Path(config["file"])
logging.info( logger.info(
"ns-2 scripted mobility configured for WLAN %d using file: %s", "ns-2 scripted mobility configured for WLAN %d using file: %s",
self.id, self.id,
self.file, self.file,
@ -955,11 +957,11 @@ class Ns2ScriptedMobility(WayPointMobility):
try: try:
f = file_path.open("r") f = file_path.open("r")
except IOError: except IOError:
logging.exception( logger.exception(
"ns-2 scripted mobility failed to load file: %s", self.file "ns-2 scripted mobility failed to load file: %s", self.file
) )
return return
logging.info("reading ns-2 script file: %s", file_path) logger.info("reading ns-2 script file: %s", file_path)
ln = 0 ln = 0
ix = iy = iz = None ix = iy = iz = None
inodenum = None inodenum = None
@ -1002,7 +1004,7 @@ class Ns2ScriptedMobility(WayPointMobility):
else: else:
raise ValueError raise ValueError
except ValueError: except ValueError:
logging.exception( logger.exception(
"skipping line %d of file %s '%s'", ln, self.file, line "skipping line %d of file %s '%s'", ln, self.file, line
) )
continue continue
@ -1052,7 +1054,7 @@ class Ns2ScriptedMobility(WayPointMobility):
raise ValueError raise ValueError
self.nodemap[int(parts[0])] = int(parts[1]) self.nodemap[int(parts[0])] = int(parts[1])
except ValueError: except ValueError:
logging.exception("ns-2 mobility node map error") logger.exception("ns-2 mobility node map error")
def map(self, nodenum: str) -> int: def map(self, nodenum: str) -> int:
""" """
@ -1074,19 +1076,19 @@ class Ns2ScriptedMobility(WayPointMobility):
:return: nothing :return: nothing
""" """
if self.autostart == "": if self.autostart == "":
logging.info("not auto-starting ns-2 script for %s", self.net.name) logger.info("not auto-starting ns-2 script for %s", self.net.name)
return return
try: try:
t = float(self.autostart) t = float(self.autostart)
except ValueError: except ValueError:
logging.exception( logger.exception(
"Invalid auto-start seconds specified '%s' for %s", "Invalid auto-start seconds specified '%s' for %s",
self.autostart, self.autostart,
self.net.name, self.net.name,
) )
return return
self.movenodesinitial() self.movenodesinitial()
logging.info("scheduling ns-2 script for %s autostart at %s", self.net.name, t) logger.info("scheduling ns-2 script for %s autostart at %s", self.net.name, t)
self.state = self.STATE_RUNNING self.state = self.STATE_RUNNING
self.session.event_loop.add_event(t, self.run) self.session.event_loop.add_event(t, self.run)
@ -1096,7 +1098,7 @@ class Ns2ScriptedMobility(WayPointMobility):
:return: nothing :return: nothing
""" """
logging.info("starting script: %s", self.file) logger.info("starting script: %s", self.file)
laststate = self.state laststate = self.state
super().start() super().start()
if laststate == self.STATE_PAUSED: if laststate == self.STATE_PAUSED:
@ -1117,7 +1119,7 @@ class Ns2ScriptedMobility(WayPointMobility):
:return: nothing :return: nothing
""" """
logging.info("pausing script: %s", self.file) logger.info("pausing script: %s", self.file)
super().pause() super().pause()
self.statescript("pause") self.statescript("pause")
@ -1129,7 +1131,7 @@ class Ns2ScriptedMobility(WayPointMobility):
position position
:return: nothing :return: nothing
""" """
logging.info("stopping script: %s", self.file) logger.info("stopping script: %s", self.file)
super().stop(move_initial=move_initial) super().stop(move_initial=move_initial)
self.statescript("stop") self.statescript("stop")

28
daemon/core/nodes/base.py
View file

@ -21,6 +21,8 @@ from core.nodes.client import VnodeClient
from core.nodes.interface import CoreInterface, TunTap, Veth from core.nodes.interface import CoreInterface, TunTap, Veth
from core.nodes.netclient import LinuxNetClient, get_net_client from core.nodes.netclient import LinuxNetClient, get_net_client
logger = logging.getLogger(__name__)
if TYPE_CHECKING: if TYPE_CHECKING:
from core.emulator.distributed import DistributedServer from core.emulator.distributed import DistributedServer
from core.emulator.session import Session from core.emulator.session import Session
@ -404,7 +406,7 @@ class CoreNodeBase(NodeBase):
if iface_id not in self.ifaces: if iface_id not in self.ifaces:
raise CoreError(f"node({self.name}) interface({iface_id}) does not exist") raise CoreError(f"node({self.name}) interface({iface_id}) does not exist")
iface = self.ifaces.pop(iface_id) iface = self.ifaces.pop(iface_id)
logging.info("node(%s) removing interface(%s)", self.name, iface.name) logger.info("node(%s) removing interface(%s)", self.name, iface.name)
iface.detachnet() iface.detachnet()
iface.shutdown() iface.shutdown()
@ -547,17 +549,17 @@ class CoreNode(CoreNodeBase):
output = self.host_cmd(vnoded, env=env) output = self.host_cmd(vnoded, env=env)
self.pid = int(output) self.pid = int(output)
logging.debug("node(%s) pid: %s", self.name, self.pid) logger.debug("node(%s) pid: %s", self.name, self.pid)
# create vnode client # create vnode client
self.client = VnodeClient(self.name, self.ctrlchnlname) self.client = VnodeClient(self.name, self.ctrlchnlname)
# bring up the loopback interface # bring up the loopback interface
logging.debug("bringing up loopback interface") logger.debug("bringing up loopback interface")
self.node_net_client.device_up("lo") self.node_net_client.device_up("lo")
# set hostname for node # set hostname for node
logging.debug("setting hostname: %s", self.name) logger.debug("setting hostname: %s", self.name)
self.node_net_client.set_hostname(self.name) self.node_net_client.set_hostname(self.name)
# mark node as up # mark node as up
@ -588,18 +590,18 @@ class CoreNode(CoreNodeBase):
try: try:
self.host_cmd(f"kill -9 {self.pid}") self.host_cmd(f"kill -9 {self.pid}")
except CoreCommandError: except CoreCommandError:
logging.exception("error killing process") logger.exception("error killing process")
# remove node directory if present # remove node directory if present
try: try:
self.host_cmd(f"rm -rf {self.ctrlchnlname}") self.host_cmd(f"rm -rf {self.ctrlchnlname}")
except CoreCommandError: except CoreCommandError:
logging.exception("error removing node directory") logger.exception("error removing node directory")
# clear interface data, close client, and mark self and not up # clear interface data, close client, and mark self and not up
self.ifaces.clear() self.ifaces.clear()
self.client.close() self.client.close()
self.up = False self.up = False
except OSError: except OSError:
logging.exception("error during shutdown") logger.exception("error during shutdown")
finally: finally:
self.rmnodedir() self.rmnodedir()
@ -668,7 +670,7 @@ class CoreNode(CoreNodeBase):
:return: nothing :return: nothing
:raises CoreCommandError: when a non-zero exit status occurs :raises CoreCommandError: when a non-zero exit status occurs
""" """
logging.debug("node(%s) mounting: %s at %s", self.name, src_path, target_path) logger.debug("node(%s) mounting: %s at %s", self.name, src_path, target_path)
self.cmd(f"mkdir -p {target_path}") self.cmd(f"mkdir -p {target_path}")
self.cmd(f"{MOUNT} -n --bind {src_path} {target_path}") self.cmd(f"{MOUNT} -n --bind {src_path} {target_path}")
self._mounts.append((src_path, target_path)) self._mounts.append((src_path, target_path))
@ -726,9 +728,9 @@ class CoreNode(CoreNodeBase):
if self.up: if self.up:
flow_id = self.node_net_client.get_ifindex(veth.name) flow_id = self.node_net_client.get_ifindex(veth.name)
veth.flow_id = int(flow_id) veth.flow_id = int(flow_id)
logging.debug("interface flow index: %s - %s", veth.name, veth.flow_id) logger.debug("interface flow index: %s - %s", veth.name, veth.flow_id)
mac = self.node_net_client.get_mac(veth.name) mac = self.node_net_client.get_mac(veth.name)
logging.debug("interface mac: %s - %s", veth.name, mac) logger.debug("interface mac: %s - %s", veth.name, mac)
veth.set_mac(mac) veth.set_mac(mac)
try: try:
@ -867,7 +869,7 @@ class CoreNode(CoreNodeBase):
:return: nothing :return: nothing
:raises CoreCommandError: when a non-zero exit status occurs :raises CoreCommandError: when a non-zero exit status occurs
""" """
logging.info("adding file from %s to %s", src_path, file_path) logger.info("adding file from %s to %s", src_path, file_path)
directory = file_path.parent directory = file_path.parent
if self.server is None: if self.server is None:
self.client.check_cmd(f"mkdir -p {directory}") self.client.check_cmd(f"mkdir -p {directory}")
@ -898,7 +900,7 @@ class CoreNode(CoreNodeBase):
self.host_cmd(f"mkdir -m {0o755:o} -p {directory}") self.host_cmd(f"mkdir -m {0o755:o} -p {directory}")
self.server.remote_put_temp(host_path, contents) self.server.remote_put_temp(host_path, contents)
self.host_cmd(f"chmod {mode:o} {host_path}") self.host_cmd(f"chmod {mode:o} {host_path}")
logging.debug("node(%s) added file: %s; mode: 0%o", self.name, host_path, mode) logger.debug("node(%s) added file: %s; mode: 0%o", self.name, host_path, mode)
def nodefilecopy(self, file_path: Path, src_path: Path, mode: int = None) -> None: def nodefilecopy(self, file_path: Path, src_path: Path, mode: int = None) -> None:
""" """
@ -917,7 +919,7 @@ class CoreNode(CoreNodeBase):
self.server.remote_put(src_path, host_path) self.server.remote_put(src_path, host_path)
if mode is not None: if mode is not None:
self.host_cmd(f"chmod {mode:o} {host_path}") self.host_cmd(f"chmod {mode:o} {host_path}")
logging.info("node(%s) copied file: %s; mode: %s", self.name, host_path, mode) logger.info("node(%s) copied file: %s; mode: %s", self.name, host_path, mode)
class CoreNetworkBase(NodeBase): class CoreNetworkBase(NodeBase):

16
daemon/core/nodes/docker.py
View file

@ -11,6 +11,8 @@ from core.errors import CoreCommandError
from core.nodes.base import CoreNode from core.nodes.base import CoreNode
from core.nodes.netclient import LinuxNetClient, get_net_client from core.nodes.netclient import LinuxNetClient, get_net_client
logger = logging.getLogger(__name__)
if TYPE_CHECKING: if TYPE_CHECKING:
from core.emulator.session import Session from core.emulator.session import Session
@ -50,7 +52,7 @@ class DockerClient:
self.run(f"docker rm -f {self.name}") self.run(f"docker rm -f {self.name}")
def check_cmd(self, cmd: str, wait: bool = True, shell: bool = False) -> str: def check_cmd(self, cmd: str, wait: bool = True, shell: bool = False) -> str:
logging.info("docker cmd output: %s", cmd) logger.info("docker cmd output: %s", cmd)
return utils.cmd(f"docker exec {self.name} {cmd}", wait=wait, shell=shell) return utils.cmd(f"docker exec {self.name} {cmd}", wait=wait, shell=shell)
def create_ns_cmd(self, cmd: str) -> str: def create_ns_cmd(self, cmd: str) -> str:
@ -60,7 +62,7 @@ class DockerClient:
args = f"docker inspect -f '{{{{.State.Pid}}}}' {self.name}" args = f"docker inspect -f '{{{{.State.Pid}}}}' {self.name}"
output = self.run(args) output = self.run(args)
self.pid = output self.pid = output
logging.debug("node(%s) pid: %s", self.name, self.pid) logger.debug("node(%s) pid: %s", self.name, self.pid)
return output return output
def copy_file(self, src_path: Path, dst_path: Path) -> str: def copy_file(self, src_path: Path, dst_path: Path) -> str:
@ -169,7 +171,7 @@ class DockerNode(CoreNode):
:param dir_path: path to create :param dir_path: path to create
:return: nothing :return: nothing
""" """
logging.debug("creating node dir: %s", dir_path) logger.debug("creating node dir: %s", dir_path)
args = f"mkdir -p {dir_path}" args = f"mkdir -p {dir_path}"
self.cmd(args) self.cmd(args)
@ -182,7 +184,7 @@ class DockerNode(CoreNode):
:return: nothing :return: nothing
:raises CoreCommandError: when a non-zero exit status occurs :raises CoreCommandError: when a non-zero exit status occurs
""" """
logging.debug("mounting source(%s) target(%s)", src_path, target_path) logger.debug("mounting source(%s) target(%s)", src_path, target_path)
raise Exception("not supported") raise Exception("not supported")
def nodefile(self, file_path: Path, contents: str, mode: int = 0o644) -> None: def nodefile(self, file_path: Path, contents: str, mode: int = 0o644) -> None:
@ -194,7 +196,7 @@ class DockerNode(CoreNode):
:param mode: mode for file :param mode: mode for file
:return: nothing :return: nothing
""" """
logging.debug("nodefile filename(%s) mode(%s)", file_path, mode) logger.debug("nodefile filename(%s) mode(%s)", file_path, mode)
temp = NamedTemporaryFile(delete=False) temp = NamedTemporaryFile(delete=False)
temp.write(contents.encode("utf-8")) temp.write(contents.encode("utf-8"))
temp.close() temp.close()
@ -209,7 +211,7 @@ class DockerNode(CoreNode):
if self.server is not None: if self.server is not None:
self.host_cmd(f"rm -f {temp_path}") self.host_cmd(f"rm -f {temp_path}")
temp_path.unlink() temp_path.unlink()
logging.debug("node(%s) added file: %s; mode: 0%o", self.name, file_path, mode) logger.debug("node(%s) added file: %s; mode: 0%o", self.name, file_path, mode)
def nodefilecopy(self, file_path: Path, src_path: Path, mode: int = None) -> None: def nodefilecopy(self, file_path: Path, src_path: Path, mode: int = None) -> None:
""" """
@ -221,7 +223,7 @@ class DockerNode(CoreNode):
:param mode: mode to copy to :param mode: mode to copy to
:return: nothing :return: nothing
""" """
logging.info( logger.info(
"node file copy file(%s) source(%s) mode(%s)", file_path, src_path, mode "node file copy file(%s) source(%s) mode(%s)", file_path, src_path, mode
) )
self.cmd(f"mkdir -p {file_path.parent}") self.cmd(f"mkdir -p {file_path.parent}")

16
daemon/core/nodes/interface.py
View file

@ -15,6 +15,8 @@ from core.emulator.enumerations import TransportType
from core.errors import CoreCommandError, CoreError from core.errors import CoreCommandError, CoreError
from core.nodes.netclient import LinuxNetClient, get_net_client from core.nodes.netclient import LinuxNetClient, get_net_client
logger = logging.getLogger(__name__)
if TYPE_CHECKING: if TYPE_CHECKING:
from core.emulator.distributed import DistributedServer from core.emulator.distributed import DistributedServer
from core.emulator.session import Session from core.emulator.session import Session
@ -274,7 +276,7 @@ class CoreInterface:
:return: True if parameter changed, False otherwise :return: True if parameter changed, False otherwise
""" """
# treat None and 0 as unchanged values # treat None and 0 as unchanged values
logging.debug("setting param: %s - %s", key, value) logger.debug("setting param: %s - %s", key, value)
if value is None or value < 0: if value is None or value < 0:
return False return False
@ -457,7 +459,7 @@ class TunTap(CoreInterface):
try: try:
self.node.node_net_client.device_flush(self.name) self.node.node_net_client.device_flush(self.name)
except CoreCommandError: except CoreCommandError:
logging.exception("error shutting down tunnel tap") logger.exception("error shutting down tunnel tap")
self.up = False self.up = False
@ -482,14 +484,14 @@ class TunTap(CoreInterface):
msg = f"attempt {i} failed with nonzero exit status {r}" msg = f"attempt {i} failed with nonzero exit status {r}"
if i < attempts + 1: if i < attempts + 1:
msg += ", retrying..." msg += ", retrying..."
logging.info(msg) logger.info(msg)
time.sleep(delay) time.sleep(delay)
delay += delay delay += delay
if delay > maxretrydelay: if delay > maxretrydelay:
delay = maxretrydelay delay = maxretrydelay
else: else:
msg += ", giving up" msg += ", giving up"
logging.info(msg) logger.info(msg)
return result return result
@ -500,7 +502,7 @@ class TunTap(CoreInterface):
:return: wait for device local response :return: wait for device local response
""" """
logging.debug("waiting for device local: %s", self.localname) logger.debug("waiting for device local: %s", self.localname)
def localdevexists(): def localdevexists():
try: try:
@ -517,7 +519,7 @@ class TunTap(CoreInterface):
:return: nothing :return: nothing
""" """
logging.debug("waiting for device node: %s", self.name) logger.debug("waiting for device node: %s", self.name)
def nodedevexists(): def nodedevexists():
try: try:
@ -634,5 +636,5 @@ class GreTap(CoreInterface):
self.net_client.device_down(self.localname) self.net_client.device_down(self.localname)
self.net_client.delete_device(self.localname) self.net_client.delete_device(self.localname)
except CoreCommandError: except CoreCommandError:
logging.exception("error during shutdown") logger.exception("error during shutdown")
self.localname = None self.localname = None

12
daemon/core/nodes/lxd.py
View file

@ -12,6 +12,8 @@ from core.errors import CoreCommandError
from core.nodes.base import CoreNode from core.nodes.base import CoreNode
from core.nodes.interface import CoreInterface from core.nodes.interface import CoreInterface
logger = logging.getLogger(__name__)
if TYPE_CHECKING: if TYPE_CHECKING:
from core.emulator.session import Session from core.emulator.session import Session
@ -145,7 +147,7 @@ class LxcNode(CoreNode):
:param dir_path: path to create :param dir_path: path to create
:return: nothing :return: nothing
""" """
logging.info("creating node dir: %s", dir_path) logger.info("creating node dir: %s", dir_path)
args = f"mkdir -p {dir_path}" args = f"mkdir -p {dir_path}"
self.cmd(args) self.cmd(args)
@ -158,7 +160,7 @@ class LxcNode(CoreNode):
:return: nothing :return: nothing
:raises CoreCommandError: when a non-zero exit status occurs :raises CoreCommandError: when a non-zero exit status occurs
""" """
logging.debug("mounting source(%s) target(%s)", src_path, target_path) logger.debug("mounting source(%s) target(%s)", src_path, target_path)
raise Exception("not supported") raise Exception("not supported")
def nodefile(self, file_path: Path, contents: str, mode: int = 0o644) -> None: def nodefile(self, file_path: Path, contents: str, mode: int = 0o644) -> None:
@ -170,7 +172,7 @@ class LxcNode(CoreNode):
:param mode: mode for file :param mode: mode for file
:return: nothing :return: nothing
""" """
logging.debug("nodefile filename(%s) mode(%s)", file_path, mode) logger.debug("nodefile filename(%s) mode(%s)", file_path, mode)
temp = NamedTemporaryFile(delete=False) temp = NamedTemporaryFile(delete=False)
temp.write(contents.encode("utf-8")) temp.write(contents.encode("utf-8"))
temp.close() temp.close()
@ -185,7 +187,7 @@ class LxcNode(CoreNode):
if self.server is not None: if self.server is not None:
self.host_cmd(f"rm -f {temp_path}") self.host_cmd(f"rm -f {temp_path}")
temp_path.unlink() temp_path.unlink()
logging.debug("node(%s) added file: %s; mode: 0%o", self.name, file_path, mode) logger.debug("node(%s) added file: %s; mode: 0%o", self.name, file_path, mode)
def nodefilecopy(self, file_path: Path, src_path: Path, mode: int = None) -> None: def nodefilecopy(self, file_path: Path, src_path: Path, mode: int = None) -> None:
""" """
@ -197,7 +199,7 @@ class LxcNode(CoreNode):
:param mode: mode to copy to :param mode: mode to copy to
:return: nothing :return: nothing
""" """
logging.info( logger.info(
"node file copy file(%s) source(%s) mode(%s)", file_path, src_path, mode "node file copy file(%s) source(%s) mode(%s)", file_path, src_path, mode
) )
self.cmd(f"mkdir -p {file_path.parent}") self.cmd(f"mkdir -p {file_path.parent}")

24
daemon/core/nodes/network.py
View file

@ -26,6 +26,8 @@ from core.nodes.base import CoreNetworkBase
from core.nodes.interface import CoreInterface, GreTap, Veth from core.nodes.interface import CoreInterface, GreTap, Veth
from core.nodes.netclient import get_net_client from core.nodes.netclient import get_net_client
logger = logging.getLogger(__name__)
if TYPE_CHECKING: if TYPE_CHECKING:
from core.emulator.distributed import DistributedServer from core.emulator.distributed import DistributedServer
from core.emulator.session import Session from core.emulator.session import Session
@ -90,7 +92,7 @@ class EbtablesQueue:
try: try:
del self.last_update_time[wlan] del self.last_update_time[wlan]
except KeyError: except KeyError:
logging.exception( logger.exception(
"error deleting last update time for wlan, ignored before: %s", wlan "error deleting last update time for wlan, ignored before: %s", wlan
) )
if len(self.last_update_time) > 0: if len(self.last_update_time) > 0:
@ -186,7 +188,7 @@ class EbtablesQueue:
try: try:
wlan.host_cmd(f"rm -f {self.atomic_file}") wlan.host_cmd(f"rm -f {self.atomic_file}")
except CoreCommandError: except CoreCommandError:
logging.exception("error removing atomic file: %s", self.atomic_file) logger.exception("error removing atomic file: %s", self.atomic_file)
def ebchange(self, wlan: "CoreNetwork") -> None: def ebchange(self, wlan: "CoreNetwork") -> None:
""" """
@ -309,7 +311,7 @@ class CoreNetwork(CoreNetworkBase):
:return: combined stdout and stderr :return: combined stdout and stderr
:raises CoreCommandError: when a non-zero exit status occurs :raises CoreCommandError: when a non-zero exit status occurs
""" """
logging.debug("network node(%s) cmd", self.name) logger.debug("network node(%s) cmd", self.name)
output = utils.cmd(args, env, cwd, wait, shell) output = utils.cmd(args, env, cwd, wait, shell)
self.session.distributed.execute(lambda x: x.remote_cmd(args, env, cwd, wait)) self.session.distributed.execute(lambda x: x.remote_cmd(args, env, cwd, wait))
return output return output
@ -344,7 +346,7 @@ class CoreNetwork(CoreNetworkBase):
] ]
ebtablescmds(self.host_cmd, cmds) ebtablescmds(self.host_cmd, cmds)
except CoreCommandError: except CoreCommandError:
logging.exception("error during shutdown") logger.exception("error during shutdown")
# removes veth pairs used for bridge-to-bridge connections # removes veth pairs used for bridge-to-bridge connections
for iface in self.get_ifaces(): for iface in self.get_ifaces():
iface.shutdown() iface.shutdown()
@ -763,7 +765,7 @@ class CtrlNet(CoreNetwork):
raise CoreError(f"old bridges exist for node: {self.id}") raise CoreError(f"old bridges exist for node: {self.id}")
super().startup() super().startup()
logging.info("added control network bridge: %s %s", self.brname, self.prefix) logger.info("added control network bridge: %s %s", self.brname, self.prefix)
if self.hostid and self.assign_address: if self.hostid and self.assign_address:
self.add_addresses(self.hostid) self.add_addresses(self.hostid)
@ -771,7 +773,7 @@ class CtrlNet(CoreNetwork):
self.add_addresses(-2) self.add_addresses(-2)
if self.updown_script: if self.updown_script:
logging.info( logger.info(
"interface %s updown script (%s startup) called", "interface %s updown script (%s startup) called",
self.brname, self.brname,
self.updown_script, self.updown_script,
@ -791,7 +793,7 @@ class CtrlNet(CoreNetwork):
try: try:
self.net_client.delete_iface(self.brname, self.serverintf) self.net_client.delete_iface(self.brname, self.serverintf)
except CoreCommandError: except CoreCommandError:
logging.exception( logger.exception(
"error deleting server interface %s from bridge %s", "error deleting server interface %s from bridge %s",
self.serverintf, self.serverintf,
self.brname, self.brname,
@ -799,14 +801,14 @@ class CtrlNet(CoreNetwork):
if self.updown_script is not None: if self.updown_script is not None:
try: try:
logging.info( logger.info(
"interface %s updown script (%s shutdown) called", "interface %s updown script (%s shutdown) called",
self.brname, self.brname,
self.updown_script, self.updown_script,
) )
self.host_cmd(f"{self.updown_script} {self.brname} shutdown") self.host_cmd(f"{self.updown_script} {self.brname} shutdown")
except CoreCommandError: except CoreCommandError:
logging.exception("error issuing shutdown script shutdown") logger.exception("error issuing shutdown script shutdown")
super().shutdown() super().shutdown()
@ -1006,7 +1008,7 @@ class WlanNode(CoreNetwork):
:param config: configuration for model being set :param config: configuration for model being set
:return: nothing :return: nothing
""" """
logging.debug("node(%s) setting model: %s", self.name, model.name) logger.debug("node(%s) setting model: %s", self.name, model.name)
if model.config_type == RegisterTlvs.WIRELESS: if model.config_type == RegisterTlvs.WIRELESS:
self.model = model(session=self.session, _id=self.id) self.model = model(session=self.session, _id=self.id)
for iface in self.get_ifaces(): for iface in self.get_ifaces():
@ -1025,7 +1027,7 @@ class WlanNode(CoreNetwork):
def updatemodel(self, config: Dict[str, str]) -> None: def updatemodel(self, config: Dict[str, str]) -> None:
if not self.model: if not self.model:
raise CoreError(f"no model set to update for node({self.name})") raise CoreError(f"no model set to update for node({self.name})")
logging.debug( logger.debug(
"node(%s) updating model(%s): %s", self.id, self.model.name, config "node(%s) updating model(%s): %s", self.id, self.model.name, config
) )
self.model.update_config(config) self.model.update_config(config)

16
daemon/core/nodes/physical.py
View file

@ -16,6 +16,8 @@ from core.nodes.base import CoreNetworkBase, CoreNodeBase
from core.nodes.interface import DEFAULT_MTU, CoreInterface from core.nodes.interface import DEFAULT_MTU, CoreInterface
from core.nodes.network import CoreNetwork, GreTap from core.nodes.network import CoreNetwork, GreTap
logger = logging.getLogger(__name__)
if TYPE_CHECKING: if TYPE_CHECKING:
from core.emulator.session import Session from core.emulator.session import Session
@ -163,7 +165,7 @@ class PhysicalNode(CoreNodeBase):
def new_iface( def new_iface(
self, net: CoreNetworkBase, iface_data: InterfaceData self, net: CoreNetworkBase, iface_data: InterfaceData
) -> CoreInterface: ) -> CoreInterface:
logging.info("creating interface") logger.info("creating interface")
ips = iface_data.get_ips() ips = iface_data.get_ips()
iface_id = iface_data.id iface_id = iface_data.id
if iface_id is None: if iface_id is None:
@ -191,17 +193,17 @@ class PhysicalNode(CoreNodeBase):
self.mount(host_path, dir_path) self.mount(host_path, dir_path)
def mount(self, src_path: Path, target_path: Path) -> None: def mount(self, src_path: Path, target_path: Path) -> None:
logging.debug("node(%s) mounting: %s at %s", self.name, src_path, target_path) logger.debug("node(%s) mounting: %s at %s", self.name, src_path, target_path)
self.cmd(f"mkdir -p {target_path}") self.cmd(f"mkdir -p {target_path}")
self.host_cmd(f"{MOUNT} --bind {src_path} {target_path}", cwd=self.directory) self.host_cmd(f"{MOUNT} --bind {src_path} {target_path}", cwd=self.directory)
self._mounts.append((src_path, target_path)) self._mounts.append((src_path, target_path))
def umount(self, target_path: Path) -> None: def umount(self, target_path: Path) -> None:
logging.info("unmounting '%s'", target_path) logger.info("unmounting '%s'", target_path)
try: try:
self.host_cmd(f"{UMOUNT} -l {target_path}", cwd=self.directory) self.host_cmd(f"{UMOUNT} -l {target_path}", cwd=self.directory)
except CoreCommandError: except CoreCommandError:
logging.exception("unmounting failed for %s", target_path) logger.exception("unmounting failed for %s", target_path)
def nodefile(self, file_path: Path, contents: str, mode: int = 0o644) -> None: def nodefile(self, file_path: Path, contents: str, mode: int = 0o644) -> None:
host_path = self.host_path(file_path) host_path = self.host_path(file_path)
@ -211,7 +213,7 @@ class PhysicalNode(CoreNodeBase):
with host_path.open("w") as f: with host_path.open("w") as f:
f.write(contents) f.write(contents)
host_path.chmod(mode) host_path.chmod(mode)
logging.info("created nodefile: '%s'; mode: 0%o", host_path, mode) logger.info("created nodefile: '%s'; mode: 0%o", host_path, mode)
def cmd(self, args: str, wait: bool = True, shell: bool = False) -> str: def cmd(self, args: str, wait: bool = True, shell: bool = False) -> str:
return self.host_cmd(args, wait=wait) return self.host_cmd(args, wait=wait)
@ -415,7 +417,7 @@ class Rj45Node(CoreNodeBase):
if items[1][:4] == "fe80": if items[1][:4] == "fe80":
continue continue
self.old_addrs.append((items[1], None)) self.old_addrs.append((items[1], None))
logging.info("saved rj45 state: addrs(%s) up(%s)", self.old_addrs, self.old_up) logger.info("saved rj45 state: addrs(%s) up(%s)", self.old_addrs, self.old_up)
def restorestate(self) -> None: def restorestate(self) -> None:
""" """
@ -425,7 +427,7 @@ class Rj45Node(CoreNodeBase):
:raises CoreCommandError: when there is a command exception :raises CoreCommandError: when there is a command exception
""" """
localname = self.iface.localname localname = self.iface.localname
logging.info("restoring rj45 state: %s", localname) logger.info("restoring rj45 state: %s", localname)
for addr in self.old_addrs: for addr in self.old_addrs:
self.net_client.create_address(localname, addr[0], addr[1]) self.net_client.create_address(localname, addr[0], addr[1])
if self.old_up: if self.old_up:

30
daemon/core/plugins/sdt.py
View file

@ -15,6 +15,8 @@ from core.errors import CoreError
from core.nodes.base import CoreNetworkBase, NodeBase from core.nodes.base import CoreNetworkBase, NodeBase
from core.nodes.network import WlanNode from core.nodes.network import WlanNode
logger = logging.getLogger(__name__)
if TYPE_CHECKING: if TYPE_CHECKING:
from core.emulator.session import Session from core.emulator.session import Session
@ -109,7 +111,7 @@ class Sdt:
return False return False
self.seturl() self.seturl()
logging.info("connecting to SDT at %s://%s", self.protocol, self.address) logger.info("connecting to SDT at %s://%s", self.protocol, self.address)
if self.sock is None: if self.sock is None:
try: try:
if self.protocol.lower() == "udp": if self.protocol.lower() == "udp":
@ -119,7 +121,7 @@ class Sdt:
# Default to tcp # Default to tcp
self.sock = socket.create_connection(self.address, 5) self.sock = socket.create_connection(self.address, 5)
except IOError: except IOError:
logging.exception("SDT socket connect error") logger.exception("SDT socket connect error")
return False return False
if not self.initialize(): if not self.initialize():
@ -157,7 +159,7 @@ class Sdt:
try: try:
self.sock.close() self.sock.close()
except IOError: except IOError:
logging.error("error closing socket") logger.error("error closing socket")
finally: finally:
self.sock = None self.sock = None
@ -191,11 +193,11 @@ class Sdt:
try: try:
cmd = f"{cmdstr}\n".encode() cmd = f"{cmdstr}\n".encode()
logging.debug("sdt cmd: %s", cmd) logger.debug("sdt cmd: %s", cmd)
self.sock.sendall(cmd) self.sock.sendall(cmd)
return True return True
except IOError: except IOError:
logging.exception("SDT connection error") logger.exception("SDT connection error")
self.sock = None self.sock = None
self.connected = False self.connected = False
return False return False
@ -250,7 +252,7 @@ class Sdt:
:param node: node to add :param node: node to add
:return: nothing :return: nothing
""" """
logging.debug("sdt add node: %s - %s", node.id, node.name) logger.debug("sdt add node: %s - %s", node.id, node.name)
if not self.connect(): if not self.connect():
return return
pos = self.get_node_position(node) pos = self.get_node_position(node)
@ -262,8 +264,8 @@ class Sdt:
icon = node.icon icon = node.icon
if icon: if icon:
node_type = node.name node_type = node.name
icon = icon.replace("$CORE_DATA_DIR", CORE_DATA_DIR) icon = icon.replace("$CORE_DATA_DIR", str(CORE_DATA_DIR))
icon = icon.replace("$CORE_CONF_DIR", CORE_CONF_DIR) icon = icon.replace("$CORE_CONF_DIR", str(CORE_CONF_DIR))
self.cmd(f"sprite {node_type} image {icon}") self.cmd(f"sprite {node_type} image {icon}")
self.cmd( self.cmd(
f'node {node.id} nodeLayer "{NODE_LAYER}" ' f'node {node.id} nodeLayer "{NODE_LAYER}" '
@ -280,7 +282,7 @@ class Sdt:
:param alt: node altitude :param alt: node altitude
:return: nothing :return: nothing
""" """
logging.debug("sdt update node: %s - %s", node.id, node.name) logger.debug("sdt update node: %s - %s", node.id, node.name)
if not self.connect(): if not self.connect():
return return
@ -300,7 +302,7 @@ class Sdt:
:param node_id: node id to delete :param node_id: node id to delete
:return: nothing :return: nothing
""" """
logging.debug("sdt delete node: %s", node_id) logger.debug("sdt delete node: %s", node_id)
if not self.connect(): if not self.connect():
return return
self.cmd(f"delete node,{node_id}") self.cmd(f"delete node,{node_id}")
@ -315,7 +317,7 @@ class Sdt:
if not self.connect(): if not self.connect():
return return
node = node_data.node node = node_data.node
logging.debug("sdt handle node update: %s - %s", node.id, node.name) logger.debug("sdt handle node update: %s - %s", node.id, node.name)
if node_data.message_type == MessageFlags.DELETE: if node_data.message_type == MessageFlags.DELETE:
self.cmd(f"delete node,{node.id}") self.cmd(f"delete node,{node.id}")
else: else:
@ -356,7 +358,7 @@ class Sdt:
:param label: label for link :param label: label for link
:return: nothing :return: nothing
""" """
logging.debug("sdt add link: %s, %s, %s", node1_id, node2_id, network_id) logger.debug("sdt add link: %s, %s, %s", node1_id, node2_id, network_id)
if not self.connect(): if not self.connect():
return return
if self.wireless_net_check(node1_id) or self.wireless_net_check(node2_id): if self.wireless_net_check(node1_id) or self.wireless_net_check(node2_id):
@ -396,7 +398,7 @@ class Sdt:
:param network_id: network link is associated with, None otherwise :param network_id: network link is associated with, None otherwise
:return: nothing :return: nothing
""" """
logging.debug("sdt delete link: %s, %s, %s", node1_id, node2_id, network_id) logger.debug("sdt delete link: %s, %s, %s", node1_id, node2_id, network_id)
if not self.connect(): if not self.connect():
return return
if self.wireless_net_check(node1_id) or self.wireless_net_check(node2_id): if self.wireless_net_check(node1_id) or self.wireless_net_check(node2_id):
@ -416,7 +418,7 @@ class Sdt:
:param label: label to update :param label: label to update
:return: nothing :return: nothing
""" """
logging.debug("sdt edit link: %s, %s, %s", node1_id, node2_id, network_id) logger.debug("sdt edit link: %s, %s, %s", node1_id, node2_id, network_id)
if not self.connect(): if not self.connect():
return return
if self.wireless_net_check(node1_id) or self.wireless_net_check(node2_id): if self.wireless_net_check(node1_id) or self.wireless_net_check(node2_id):

52
daemon/core/services/coreservices.py
View file

@ -34,6 +34,8 @@ from core.errors import (
) )
from core.nodes.base import CoreNode from core.nodes.base import CoreNode
logger = logging.getLogger(__name__)
if TYPE_CHECKING: if TYPE_CHECKING:
from core.emulator.session import Session from core.emulator.session import Session
@ -161,7 +163,7 @@ class ServiceShim:
cls.setvalue(service, key, values[cls.keys.index(key)]) cls.setvalue(service, key, values[cls.keys.index(key)])
except IndexError: except IndexError:
# old config does not need to have new keys # old config does not need to have new keys
logging.exception("error indexing into key") logger.exception("error indexing into key")
@classmethod @classmethod
def setvalue(cls, service: "CoreService", key: str, value: str) -> None: def setvalue(cls, service: "CoreService", key: str, value: str) -> None:
@ -228,7 +230,7 @@ class ServiceManager:
:raises ValueError: when service cannot be loaded :raises ValueError: when service cannot be loaded
""" """
name = service.name name = service.name
logging.debug("loading service: class(%s) name(%s)", service.__name__, name) logger.debug("loading service: class(%s) name(%s)", service.__name__, name)
# avoid duplicate services # avoid duplicate services
if name in cls.services: if name in cls.services:
@ -245,7 +247,7 @@ class ServiceManager:
try: try:
service.on_load() service.on_load()
except Exception as e: except Exception as e:
logging.exception("error during service(%s) on load", service.name) logger.exception("error during service(%s) on load", service.name)
raise ValueError(e) raise ValueError(e)
# make service available # make service available
@ -281,7 +283,7 @@ class ServiceManager:
cls.add(service) cls.add(service)
except (CoreError, ValueError) as e: except (CoreError, ValueError) as e:
service_errors.append(service.name) service_errors.append(service.name)
logging.debug("not loading service(%s): %s", service.name, e) logger.debug("not loading service(%s): %s", service.name, e)
return service_errors return service_errors
@ -329,14 +331,14 @@ class CoreServices:
:param node_type: node type to get default services for :param node_type: node type to get default services for
:return: default services :return: default services
""" """
logging.debug("getting default services for type: %s", node_type) logger.debug("getting default services for type: %s", node_type)
results = [] results = []
defaults = self.default_services.get(node_type, []) defaults = self.default_services.get(node_type, [])
for name in defaults: for name in defaults:
logging.debug("checking for service with service manager: %s", name) logger.debug("checking for service with service manager: %s", name)
service = ServiceManager.get(name) service = ServiceManager.get(name)
if not service: if not service:
logging.warning("default service %s is unknown", name) logger.warning("default service %s is unknown", name)
else: else:
results.append(service) results.append(service)
return results return results
@ -369,7 +371,7 @@ class CoreServices:
:param service_name: name of service to set :param service_name: name of service to set
:return: nothing :return: nothing
""" """
logging.debug("setting custom service(%s) for node: %s", service_name, node_id) logger.debug("setting custom service(%s) for node: %s", service_name, node_id)
service = self.get_service(node_id, service_name) service = self.get_service(node_id, service_name)
if not service: if not service:
service_class = ServiceManager.get(service_name) service_class = ServiceManager.get(service_name)
@ -391,15 +393,15 @@ class CoreServices:
:return: nothing :return: nothing
""" """
if not services: if not services:
logging.info( logger.info(
"using default services for node(%s) type(%s)", node.name, node_type "using default services for node(%s) type(%s)", node.name, node_type
) )
services = self.default_services.get(node_type, []) services = self.default_services.get(node_type, [])
logging.info("setting services for node(%s): %s", node.name, services) logger.info("setting services for node(%s): %s", node.name, services)
for service_name in services: for service_name in services:
service = self.get_service(node.id, service_name, default_service=True) service = self.get_service(node.id, service_name, default_service=True)
if not service: if not service:
logging.warning( logger.warning(
"unknown service(%s) for node(%s)", service_name, node.name "unknown service(%s) for node(%s)", service_name, node.name
) )
continue continue
@ -457,7 +459,7 @@ class CoreServices:
raise CoreServiceBootError(*exceptions) raise CoreServiceBootError(*exceptions)
def _boot_service_path(self, node: CoreNode, boot_path: List["CoreServiceType"]): def _boot_service_path(self, node: CoreNode, boot_path: List["CoreServiceType"]):
logging.info( logger.info(
"booting node(%s) services: %s", "booting node(%s) services: %s",
node.name, node.name,
" -> ".join([x.name for x in boot_path]), " -> ".join([x.name for x in boot_path]),
@ -467,7 +469,7 @@ class CoreServices:
try: try:
self.boot_service(node, service) self.boot_service(node, service)
except Exception as e: except Exception as e:
logging.exception("exception booting service: %s", service.name) logger.exception("exception booting service: %s", service.name)
raise CoreServiceBootError(e) raise CoreServiceBootError(e)
def boot_service(self, node: CoreNode, service: "CoreServiceType") -> None: def boot_service(self, node: CoreNode, service: "CoreServiceType") -> None:
@ -479,7 +481,7 @@ class CoreServices:
:param service: service to start :param service: service to start
:return: nothing :return: nothing
""" """
logging.info( logger.info(
"starting node(%s) service(%s) validation(%s)", "starting node(%s) service(%s) validation(%s)",
node.name, node.name,
service.name, service.name,
@ -492,7 +494,7 @@ class CoreServices:
try: try:
node.privatedir(dir_path) node.privatedir(dir_path)
except (CoreCommandError, CoreError) as e: except (CoreCommandError, CoreError) as e:
logging.warning( logger.warning(
"error mounting private dir '%s' for service '%s': %s", "error mounting private dir '%s' for service '%s': %s",
directory, directory,
service.name, service.name,
@ -563,21 +565,21 @@ class CoreServices:
:param service: service to validate :param service: service to validate
:return: service validation status :return: service validation status
""" """
logging.debug("validating node(%s) service(%s)", node.name, service.name) logger.debug("validating node(%s) service(%s)", node.name, service.name)
cmds = service.validate cmds = service.validate
if not service.custom: if not service.custom:
cmds = service.get_validate(node) cmds = service.get_validate(node)
status = 0 status = 0
for cmd in cmds: for cmd in cmds:
logging.debug("validating service(%s) using: %s", service.name, cmd) logger.debug("validating service(%s) using: %s", service.name, cmd)
try: try:
node.cmd(cmd) node.cmd(cmd)
except CoreCommandError as e: except CoreCommandError as e:
logging.debug( logger.debug(
"node(%s) service(%s) validate failed", node.name, service.name "node(%s) service(%s) validate failed", node.name, service.name
) )
logging.debug("cmd(%s): %s", e.cmd, e.output) logger.debug("cmd(%s): %s", e.cmd, e.output)
status = -1 status = -1
break break
@ -612,7 +614,7 @@ class CoreServices:
f"error stopping service {service.name}: {e.stderr}", f"error stopping service {service.name}: {e.stderr}",
node.id, node.id,
) )
logging.exception("error running stop command %s", args) logger.exception("error running stop command %s", args)
status = -1 status = -1
return status return status
@ -680,13 +682,13 @@ class CoreServices:
# retrieve custom service # retrieve custom service
service = self.get_service(node_id, service_name) service = self.get_service(node_id, service_name)
if service is None: if service is None:
logging.warning("received file name for unknown service: %s", service_name) logger.warning("received file name for unknown service: %s", service_name)
return return
# validate file being set is valid # validate file being set is valid
config_files = service.configs config_files = service.configs
if file_name not in config_files: if file_name not in config_files:
logging.warning( logger.warning(
"received unknown file(%s) for service(%s)", file_name, service_name "received unknown file(%s) for service(%s)", file_name, service_name
) )
return return
@ -714,7 +716,7 @@ class CoreServices:
try: try:
node.cmd(cmd, wait) node.cmd(cmd, wait)
except CoreCommandError: except CoreCommandError:
logging.exception("error starting command") logger.exception("error starting command")
status = -1 status = -1
return status return status
@ -732,7 +734,7 @@ class CoreServices:
config_files = service.get_configs(node) config_files = service.get_configs(node)
for file_name in config_files: for file_name in config_files:
file_path = Path(file_name) file_path = Path(file_name)
logging.debug( logger.debug(
"generating service config custom(%s): %s", service.custom, file_name "generating service config custom(%s): %s", service.custom, file_name
) )
if service.custom: if service.custom:
@ -744,7 +746,7 @@ class CoreServices:
if self.copy_service_file(node, file_path, cfg): if self.copy_service_file(node, file_path, cfg):
continue continue
except IOError: except IOError:
logging.exception("error copying service file: %s", file_name) logger.exception("error copying service file: %s", file_name)
continue continue
else: else:
cfg = service.generate_config(node, file_name) cfg = service.generate_config(node, file_name)

10
daemon/core/services/security.py
View file

@ -11,6 +11,8 @@ from core.nodes.base import CoreNode
from core.nodes.interface import CoreInterface from core.nodes.interface import CoreInterface
from core.services.coreservices import CoreService from core.services.coreservices import CoreService
logger = logging.getLogger(__name__)
class VPNClient(CoreService): class VPNClient(CoreService):
name: str = "VPNClient" name: str = "VPNClient"
@ -33,7 +35,7 @@ class VPNClient(CoreService):
with open(fname, "r") as f: with open(fname, "r") as f:
cfg += f.read() cfg += f.read()
except IOError: except IOError:
logging.exception( logger.exception(
"error opening VPN client configuration template (%s)", fname "error opening VPN client configuration template (%s)", fname
) )
return cfg return cfg
@ -61,7 +63,7 @@ class VPNServer(CoreService):
with open(fname, "r") as f: with open(fname, "r") as f:
cfg += f.read() cfg += f.read()
except IOError: except IOError:
logging.exception( logger.exception(
"Error opening VPN server configuration template (%s)", fname "Error opening VPN server configuration template (%s)", fname
) )
return cfg return cfg
@ -89,7 +91,7 @@ class IPsec(CoreService):
with open(fname, "r") as f: with open(fname, "r") as f:
cfg += f.read() cfg += f.read()
except IOError: except IOError:
logging.exception("Error opening IPsec configuration template (%s)", fname) logger.exception("Error opening IPsec configuration template (%s)", fname)
return cfg return cfg
@ -112,7 +114,7 @@ class Firewall(CoreService):
with open(fname, "r") as f: with open(fname, "r") as f:
cfg += f.read() cfg += f.read()
except IOError: except IOError:
logging.exception( logger.exception(
"Error opening Firewall configuration template (%s)", fname "Error opening Firewall configuration template (%s)", fname
) )
return cfg return cfg

20
daemon/core/utils.py
View file

@ -36,6 +36,8 @@ import netaddr
from core.errors import CoreCommandError, CoreError from core.errors import CoreCommandError, CoreError
logger = logging.getLogger(__name__)
if TYPE_CHECKING: if TYPE_CHECKING:
from core.emulator.session import Session from core.emulator.session import Session
from core.nodes.base import CoreNode from core.nodes.base import CoreNode
@ -204,7 +206,7 @@ def cmd(
:raises CoreCommandError: when there is a non-zero exit status or the file to :raises CoreCommandError: when there is a non-zero exit status or the file to
execute is not found execute is not found
""" """
logging.debug("command cwd(%s) wait(%s): %s", cwd, wait, args) logger.debug("command cwd(%s) wait(%s): %s", cwd, wait, args)
if shell is False: if shell is False:
args = shlex.split(args) args = shlex.split(args)
try: try:
@ -221,7 +223,7 @@ def cmd(
else: else:
return "" return ""
except OSError as e: except OSError as e:
logging.error("cmd error: %s", e.strerror) logger.error("cmd error: %s", e.strerror)
raise CoreCommandError(1, args, "", e.strerror) raise CoreCommandError(1, args, "", e.strerror)
@ -323,7 +325,7 @@ def load_config(file_path: Path, d: Dict[str, str]) -> None:
key, value = line.split("=", 1) key, value = line.split("=", 1)
d[key] = value.strip() d[key] = value.strip()
except ValueError: except ValueError:
logging.exception("error reading file to dict: %s", file_path) logger.exception("error reading file to dict: %s", file_path)
def load_classes(path: Path, clazz: Generic[T]) -> T: def load_classes(path: Path, clazz: Generic[T]) -> T:
@ -335,13 +337,13 @@ def load_classes(path: Path, clazz: Generic[T]) -> T:
:return: list of classes loaded :return: list of classes loaded
""" """
# validate path exists # validate path exists
logging.debug("attempting to load modules from path: %s", path) logger.debug("attempting to load modules from path: %s", path)
if not path.is_dir(): if not path.is_dir():
logging.warning("invalid custom module directory specified" ": %s", path) logger.warning("invalid custom module directory specified" ": %s", path)
# check if path is in sys.path # check if path is in sys.path
parent = str(path.parent) parent = str(path.parent)
if parent not in sys.path: if parent not in sys.path:
logging.debug("adding parent path to allow imports: %s", parent) logger.debug("adding parent path to allow imports: %s", parent)
sys.path.append(parent) sys.path.append(parent)
# import and add all service modules in the path # import and add all service modules in the path
classes = [] classes = []
@ -349,7 +351,7 @@ def load_classes(path: Path, clazz: Generic[T]) -> T:
if not _valid_module(p): if not _valid_module(p):
continue continue
import_statement = f"{path.name}.{p.stem}" import_statement = f"{path.name}.{p.stem}"
logging.debug("importing custom module: %s", import_statement) logger.debug("importing custom module: %s", import_statement)
try: try:
module = importlib.import_module(import_statement) module = importlib.import_module(import_statement)
members = inspect.getmembers(module, lambda x: _is_class(module, x, clazz)) members = inspect.getmembers(module, lambda x: _is_class(module, x, clazz))
@ -357,7 +359,7 @@ def load_classes(path: Path, clazz: Generic[T]) -> T:
valid_class = member[1] valid_class = member[1]
classes.append(valid_class) classes.append(valid_class)
except Exception: except Exception:
logging.exception( logger.exception(
"unexpected error during import, skipping: %s", import_statement "unexpected error during import, skipping: %s", import_statement
) )
return classes return classes
@ -398,7 +400,7 @@ def threadpool(
result = future.result() result = future.result()
results.append(result) results.append(result)
except Exception as e: except Exception as e:
logging.exception("thread pool exception") logger.exception("thread pool exception")
exceptions.append(e) exceptions.append(e)
return results, exceptions return results, exceptions

38
daemon/core/xml/corexml.py
View file

@ -17,6 +17,8 @@ from core.nodes.lxd import LxcNode
from core.nodes.network import CtrlNet, GreTapBridge, WlanNode from core.nodes.network import CtrlNet, GreTapBridge, WlanNode
from core.services.coreservices import CoreService from core.services.coreservices import CoreService
logger = logging.getLogger(__name__)
if TYPE_CHECKING: if TYPE_CHECKING:
from core.emane.emanemodel import EmaneModel from core.emane.emanemodel import EmaneModel
from core.emulator.session import Session from core.emulator.session import Session
@ -384,7 +386,7 @@ class CoreXmlWriter:
node_id, iface_id = utils.parse_iface_config_id(node_id) node_id, iface_id = utils.parse_iface_config_id(node_id)
for model_name in all_configs: for model_name in all_configs:
config = all_configs[model_name] config = all_configs[model_name]
logging.debug( logger.debug(
"writing emane config node(%s) model(%s)", node_id, model_name "writing emane config node(%s) model(%s)", node_id, model_name
) )
model = self.session.emane.models[model_name] model = self.session.emane.models[model_name]
@ -404,7 +406,7 @@ class CoreXmlWriter:
for model_name in all_configs: for model_name in all_configs:
config = all_configs[model_name] config = all_configs[model_name]
logging.debug( logger.debug(
"writing mobility config node(%s) model(%s)", node_id, model_name "writing mobility config node(%s) model(%s)", node_id, model_name
) )
mobility_configuration = etree.SubElement( mobility_configuration = etree.SubElement(
@ -609,7 +611,7 @@ class CoreXmlReader:
services = [] services = []
for service in node.iterchildren(): for service in node.iterchildren():
services.append(service.get("name")) services.append(service.get("name"))
logging.info( logger.info(
"reading default services for nodes(%s): %s", node_type, services "reading default services for nodes(%s): %s", node_type, services
) )
self.session.services.default_services[node_type] = services self.session.services.default_services[node_type] = services
@ -624,7 +626,7 @@ class CoreXmlReader:
name = data.get("name") name = data.get("name")
value = data.get("value") value = data.get("value")
configs[name] = value configs[name] = value
logging.info("reading session metadata: %s", configs) logger.info("reading session metadata: %s", configs)
self.session.metadata = configs self.session.metadata = configs
def read_session_options(self) -> None: def read_session_options(self) -> None:
@ -636,7 +638,7 @@ class CoreXmlReader:
name = configuration.get("name") name = configuration.get("name")
value = configuration.get("value") value = configuration.get("value")
xml_config[name] = value xml_config[name] = value
logging.info("reading session options: %s", xml_config) logger.info("reading session options: %s", xml_config)
config = self.session.options.get_configs() config = self.session.options.get_configs()
config.update(xml_config) config.update(xml_config)
@ -650,7 +652,7 @@ class CoreXmlReader:
state = get_int(hook, "state") state = get_int(hook, "state")
state = EventTypes(state) state = EventTypes(state)
data = hook.text data = hook.text
logging.info("reading hook: state(%s) name(%s)", state, name) logger.info("reading hook: state(%s) name(%s)", state, name)
self.session.add_hook(state, name, data) self.session.add_hook(state, name, data)
def read_servers(self) -> None: def read_servers(self) -> None:
@ -660,7 +662,7 @@ class CoreXmlReader:
for server in servers.iterchildren(): for server in servers.iterchildren():
name = server.get("name") name = server.get("name")
address = server.get("address") address = server.get("address")
logging.info("reading server: name(%s) address(%s)", name, address) logger.info("reading server: name(%s) address(%s)", name, address)
self.session.distributed.add_server(name, address) self.session.distributed.add_server(name, address)
def read_session_origin(self) -> None: def read_session_origin(self) -> None:
@ -672,19 +674,19 @@ class CoreXmlReader:
lon = get_float(session_origin, "lon") lon = get_float(session_origin, "lon")
alt = get_float(session_origin, "alt") alt = get_float(session_origin, "alt")
if all([lat, lon, alt]): if all([lat, lon, alt]):
logging.info("reading session reference geo: %s, %s, %s", lat, lon, alt) logger.info("reading session reference geo: %s, %s, %s", lat, lon, alt)
self.session.location.setrefgeo(lat, lon, alt) self.session.location.setrefgeo(lat, lon, alt)
scale = get_float(session_origin, "scale") scale = get_float(session_origin, "scale")
if scale: if scale:
logging.info("reading session reference scale: %s", scale) logger.info("reading session reference scale: %s", scale)
self.session.location.refscale = scale self.session.location.refscale = scale
x = get_float(session_origin, "x") x = get_float(session_origin, "x")
y = get_float(session_origin, "y") y = get_float(session_origin, "y")
z = get_float(session_origin, "z") z = get_float(session_origin, "z")
if all([x, y]): if all([x, y]):
logging.info("reading session reference xyz: %s, %s, %s", x, y, z) logger.info("reading session reference xyz: %s, %s, %s", x, y, z)
self.session.location.refxyz = (x, y, z) self.session.location.refxyz = (x, y, z)
def read_service_configs(self) -> None: def read_service_configs(self) -> None:
@ -695,7 +697,7 @@ class CoreXmlReader:
for service_configuration in service_configurations.iterchildren(): for service_configuration in service_configurations.iterchildren():
node_id = get_int(service_configuration, "node") node_id = get_int(service_configuration, "node")
service_name = service_configuration.get("name") service_name = service_configuration.get("name")
logging.info( logger.info(
"reading custom service(%s) for node(%s)", service_name, node_id "reading custom service(%s) for node(%s)", service_name, node_id
) )
self.session.services.set_service(node_id, service_name) self.session.services.set_service(node_id, service_name)
@ -790,7 +792,7 @@ class CoreXmlReader:
value = config.get("value") value = config.get("value")
configs[name] = value configs[name] = value
logging.info( logger.info(
"reading emane configuration node(%s) model(%s)", node_id, model_name "reading emane configuration node(%s) model(%s)", node_id, model_name
) )
node_id = utils.iface_config_id(node_id, iface_id) node_id = utils.iface_config_id(node_id, iface_id)
@ -811,7 +813,7 @@ class CoreXmlReader:
value = config.get("value") value = config.get("value")
configs[name] = value configs[name] = value
logging.info( logger.info(
"reading mobility configuration node(%s) model(%s)", node_id, model_name "reading mobility configuration node(%s) model(%s)", node_id, model_name
) )
self.session.mobility.set_model_config(node_id, model_name, configs) self.session.mobility.set_model_config(node_id, model_name, configs)
@ -868,7 +870,7 @@ class CoreXmlReader:
if all([lat, lon, alt]): if all([lat, lon, alt]):
options.set_location(lat, lon, alt) options.set_location(lat, lon, alt)
logging.info("reading node id(%s) model(%s) name(%s)", node_id, model, name) logger.info("reading node id(%s) model(%s) name(%s)", node_id, model, name)
self.session.add_node(_class, node_id, options) self.session.add_node(_class, node_id, options)
def read_network(self, network_element: etree.Element) -> None: def read_network(self, network_element: etree.Element) -> None:
@ -896,7 +898,7 @@ class CoreXmlReader:
if all([lat, lon, alt]): if all([lat, lon, alt]):
options.set_location(lat, lon, alt) options.set_location(lat, lon, alt)
logging.info( logger.info(
"reading node id(%s) node_type(%s) name(%s)", node_id, node_type, name "reading node id(%s) node_type(%s) name(%s)", node_id, node_type, name
) )
self.session.add_node(_class, node_id, options) self.session.add_node(_class, node_id, options)
@ -926,7 +928,7 @@ class CoreXmlReader:
for template_element in templates_element.iterchildren(): for template_element in templates_element.iterchildren():
name = template_element.get("name") name = template_element.get("name")
template = template_element.text template = template_element.text
logging.info( logger.info(
"loading xml template(%s): %s", type(template), template "loading xml template(%s): %s", type(template), template
) )
service.set_template(name, template) service.set_template(name, template)
@ -978,12 +980,12 @@ class CoreXmlReader:
options.buffer = get_int(options_element, "buffer") options.buffer = get_int(options_element, "buffer")
if options.unidirectional == 1 and node_set in node_sets: if options.unidirectional == 1 and node_set in node_sets:
logging.info("updating link node1(%s) node2(%s)", node1_id, node2_id) logger.info("updating link node1(%s) node2(%s)", node1_id, node2_id)
self.session.update_link( self.session.update_link(
node1_id, node2_id, iface1_data.id, iface2_data.id, options node1_id, node2_id, iface1_data.id, iface2_data.id, options
) )
else: else:
logging.info("adding link node1(%s) node2(%s)", node1_id, node2_id) logger.info("adding link node1(%s) node2(%s)", node1_id, node2_id)
self.session.add_link( self.session.add_link(
node1_id, node2_id, iface1_data, iface2_data, options node1_id, node2_id, iface1_data, iface2_data, options
) )

4
daemon/core/xml/emanexml.py
View file

@ -15,6 +15,8 @@ from core.nodes.interface import CoreInterface
from core.nodes.network import CtrlNet from core.nodes.network import CtrlNet
from core.xml import corexml from core.xml import corexml
logger = logging.getLogger(__name__)
if TYPE_CHECKING: if TYPE_CHECKING:
from core.emane.emanemanager import EmaneManager, StartData from core.emane.emanemanager import EmaneManager, StartData
from core.emane.emanemodel import EmaneModel from core.emane.emanemodel import EmaneModel
@ -47,7 +49,7 @@ def _value_to_params(value: str) -> Optional[Tuple[str]]:
return None return None
return values return values
except SyntaxError: except SyntaxError:
logging.exception("error in value string to param list") logger.exception("error in value string to param list")
return None return None

11
daemon/data/logging.conf
View file

@ -13,8 +13,11 @@
"format": "%(asctime)s - %(levelname)s - %(module)s:%(funcName)s - %(message)s" "format": "%(asctime)s - %(levelname)s - %(module)s:%(funcName)s - %(message)s"
} }
}, },
"root": { "loggers": {
"level": "INFO", "core": {
"handlers": ["console"] "level": "INFO",
} "handlers": ["console"],
"propagate": false
}
}
} }

10
daemon/scripts/core-daemon
View file

@ -22,6 +22,8 @@ from core.api.tlv.enumerations import CORE_API_PORT
from core.constants import CORE_CONF_DIR, COREDPY_VERSION from core.constants import CORE_CONF_DIR, COREDPY_VERSION
from core.utils import close_onexec, load_logging_config from core.utils import close_onexec, load_logging_config
logger = logging.getLogger(__name__)
def banner(): def banner():
""" """
@ -29,7 +31,7 @@ def banner():
:return: nothing :return: nothing
""" """
logging.info("CORE daemon v.%s started %s", constants.COREDPY_VERSION, time.ctime()) logger.info("CORE daemon v.%s started %s", constants.COREDPY_VERSION, time.ctime())
def start_udp(mainserver, server_address): def start_udp(mainserver, server_address):
@ -62,7 +64,7 @@ def cored(cfg):
address = (host, port) address = (host, port)
server = CoreServer(address, CoreHandler, cfg) server = CoreServer(address, CoreHandler, cfg)
except: except:
logging.exception("error starting main server on: %s:%s", host, port) logger.exception("error starting main server on: %s:%s", host, port)
sys.exit(1) sys.exit(1)
# initialize grpc api # initialize grpc api
@ -79,7 +81,7 @@ def cored(cfg):
# close handlers # close handlers
close_onexec(server.fileno()) close_onexec(server.fileno())
logging.info("CORE TLV API TCP/UDP listening on: %s:%s", host, port) logger.info("CORE TLV API TCP/UDP listening on: %s:%s", host, port)
server.serve_forever() server.serve_forever()
@ -155,7 +157,7 @@ def main():
try: try:
cored(cfg) cored(cfg)
except KeyboardInterrupt: except KeyboardInterrupt:
logging.info("keyboard interrupt, stopping core daemon") logger.info("keyboard interrupt, stopping core daemon")
if __name__ == "__main__": if __name__ == "__main__":