import atexit import logging import os import tempfile import time from Queue import Queue, Empty from itertools import repeat import grpc from concurrent import futures import core_pb2 import core_pb2_grpc from core.conf import ConfigShim from core.data import ConfigData, FileData from core.emulator.emudata import NodeOptions, InterfaceData, LinkOptions from core.enumerations import NodeTypes, EventTypes, LinkTypes, MessageFlags, ConfigFlags, ConfigDataTypes from core.misc import nodeutils from core.mobility import BasicRangeModel, Ns2ScriptedMobility from core.service import ServiceManager, ServiceShim _ONE_DAY_IN_SECONDS = 60 * 60 * 24 def convert_value(value): if value is None: return value else: return str(value) def update_proto(obj, **kwargs): for key in kwargs: value = kwargs[key] if value is not None: setattr(obj, key, value) def get_config_groups(config, configurable_options): groups = [] config_options = [] for configuration in configurable_options.configurations(): value = config[configuration.id] config_option = core_pb2.ConfigOption() config_option.label = configuration.label config_option.name = configuration.id config_option.value = value config_option.type = configuration.type.value config_option.select.extend(configuration.options) config_options.append(config_option) for config_group in configurable_options.config_groups(): start = config_group.start - 1 stop = config_group.stop config_group_proto = core_pb2.ConfigGroup() config_group_proto.name = config_group.name config_group_proto.options.extend(config_options[start: stop]) groups.append(config_group_proto) return groups def convert_link(session, link_data, link): if link_data.interface1_id is not None: node = session.get_object(link_data.node1_id) interface = node.netif(link_data.interface1_id) link.interface_one.id = link_data.interface1_id link.interface_one.name = interface.name update_proto( link.interface_one, mac=convert_value(link_data.interface1_mac), ip4=convert_value(link_data.interface1_ip4), ip4mask=link_data.interface1_ip4_mask, ip6=convert_value(link_data.interface1_ip6), ip6mask=link_data.interface1_ip6_mask ) if link_data.interface2_id is not None: node = session.get_object(link_data.node2_id) interface = node.netif(link_data.interface2_id) link.interface_two.id = link_data.interface2_id link.interface_two.name = interface.name update_proto( link.interface_two, mac=convert_value(link_data.interface2_mac), ip4=convert_value(link_data.interface2_ip4), ip4mask=link_data.interface2_ip4_mask, ip6=convert_value(link_data.interface2_ip6), ip6mask=link_data.interface2_ip6_mask ) link.node_one = link_data.node1_id link.node_two = link_data.node2_id link.type = link_data.link_type update_proto( link.options, opaque=link_data.opaque, jitter=link_data.jitter, key=link_data.key, mburst=link_data.mburst, mer=link_data.mer, per=link_data.per, bandwidth=link_data.bandwidth, burst=link_data.burst, delay=link_data.delay, dup=link_data.dup, unidirectional=link_data.unidirectional ) def send_objects(session): time.sleep(1) # find all nodes and links nodes_data = [] links_data = [] with session._objects_lock: for obj in session.objects.itervalues(): node_data = obj.data(message_type=MessageFlags.ADD.value) if node_data: nodes_data.append(node_data) node_links = obj.all_link_data(flags=MessageFlags.ADD.value) for link_data in node_links: links_data.append(link_data) # send all nodes first, so that they will exist for any links for node_data in nodes_data: session.broadcast_node(node_data) for link_data in links_data: session.broadcast_link(link_data) # send mobility model info for node_id in session.mobility.nodes(): for model_name, config in session.mobility.get_all_configs(node_id).iteritems(): model_class = session.mobility.models[model_name] logging.debug("mobility config: node(%s) class(%s) values(%s)", node_id, model_class, config) config_data = ConfigShim.config_data(0, node_id, ConfigFlags.UPDATE.value, model_class, config) session.broadcast_config(config_data) # send emane model info for node_id in session.emane.nodes(): for model_name, config in session.emane.get_all_configs(node_id).iteritems(): model_class = session.emane.models[model_name] logging.debug("emane config: node(%s) class(%s) values(%s)", node_id, model_class, config) config_data = ConfigShim.config_data(0, node_id, ConfigFlags.UPDATE.value, model_class, config) session.broadcast_config(config_data) # service customizations service_configs = session.services.all_configs() for node_id, service in service_configs: opaque = "service:%s" % service.name data_types = tuple(repeat(ConfigDataTypes.STRING.value, len(ServiceShim.keys))) node = session.get_object(node_id) values = ServiceShim.tovaluelist(node, service) config_data = ConfigData( message_type=0, node=node_id, object=session.services.name, type=ConfigFlags.UPDATE.value, data_types=data_types, data_values=values, session=str(session.session_id), opaque=opaque ) session.broadcast_config(config_data) for file_name, config_data in session.services.all_files(service): file_data = FileData( message_type=MessageFlags.ADD.value, node=node_id, name=str(file_name), type=opaque, data=str(config_data) ) session.broadcast_file(file_data) # TODO: send location info # send hook scripts for state in sorted(session._hooks.keys()): for file_name, config_data in session._hooks[state]: file_data = FileData( message_type=MessageFlags.ADD.value, name=str(file_name), type="hook:%s" % state, data=str(config_data) ) session.broadcast_file(file_data) # send session configuration session_config = session.options.get_configs() config_data = ConfigShim.config_data(0, None, ConfigFlags.UPDATE.value, session.options, session_config) session.broadcast_config(config_data) # send session metadata configs = session.metadata.get_configs() if configs: data_values = "|".join(["%s=%s" % item for item in configs.iteritems()]) data_types = tuple(ConfigDataTypes.STRING.value for _ in session.metadata.get_configs()) config_data = ConfigData( message_type=0, object=session.metadata.name, type=ConfigFlags.NONE.value, data_types=data_types, data_values=data_values ) session.broadcast_config(config_data) logging.debug("informed GUI about %d nodes and %d links", len(nodes_data), len(links_data)) class CoreGrpcServer(core_pb2_grpc.CoreApiServicer): def __init__(self, coreemu): super(CoreGrpcServer, self).__init__() self.coreemu = coreemu self.running = True atexit.register(self._exit_handler) def _exit_handler(self): logging.debug("catching exit, stop running") self.running = False def _is_running(self, context): return self.running and context.is_active() def _cancel_stream(self, context): context.abort(grpc.StatusCode.CANCELLED, "server stopping") def listen(self, address="[::]:50051"): logging.info("starting grpc api: %s", address) server = grpc.server(futures.ThreadPoolExecutor(max_workers=10)) core_pb2_grpc.add_CoreApiServicer_to_server(self, server) server.add_insecure_port(address) server.start() try: while True: time.sleep(_ONE_DAY_IN_SECONDS) except KeyboardInterrupt: server.stop(0) def get_session(self, _id, context): session = self.coreemu.sessions.get(_id) if not session: context.abort(grpc.StatusCode.NOT_FOUND, "session not found") return session def get_node(self, session, _id, context): node = session.get_object(_id) if not node: context.abort(grpc.StatusCode.NOT_FOUND, "node not found") return node def CreateSession(self, request, context): logging.debug("create session: %s", request) session = self.coreemu.create_session() session.set_state(EventTypes.DEFINITION_STATE) # default set session location session.location.setrefgeo(47.57917, -122.13232, 2.0) session.location.refscale = 150000.0 response = core_pb2.CreateSessionResponse() response.id = session.session_id response.state = session.state return response def DeleteSession(self, request, context): logging.debug("delete session: %s", request) response = core_pb2.DeleteSessionResponse() response.result = self.coreemu.delete_session(request.id) return response def GetSessions(self, request, context): logging.debug("get sessions: %s", request) response = core_pb2.GetSessionsResponse() for session_id in self.coreemu.sessions: session = self.coreemu.sessions[session_id] session_data = response.sessions.add() session_data.id = session_id session_data.state = session.state session_data.nodes = session.get_node_count() return response def GetSessionLocation(self, request, context): logging.debug("get session location: %s", request) session = self.get_session(request.id, context) x, y, z = session.location.refxyz lat, lon, alt = session.location.refgeo response = core_pb2.GetSessionLocationResponse() update_proto( response.position, x=x, y=y, z=z, lat=lat, lon=lon, alt=alt ) update_proto(response, scale=session.location.refscale) return response def SetSessionLocation(self, request, context): logging.debug("set session location: %s", request) session = self.get_session(request.id, context) session.location.refxyz = (request.position.x, request.position.y, request.position.z) session.location.setrefgeo(request.position.lat, request.position.lon, request.position.alt) session.location.refscale = request.scale response = core_pb2.SetSessionLocationResponse() response.result = True return response def SetSessionState(self, request, context): logging.debug("set session state: %s", request) response = core_pb2.SetSessionStateResponse() session = self.get_session(request.id, context) try: state = EventTypes(request.state) session.set_state(state) if state == EventTypes.INSTANTIATION_STATE: # create session directory if it does not exist if not os.path.exists(session.session_dir): os.mkdir(session.session_dir) session.instantiate() elif state == EventTypes.SHUTDOWN_STATE: session.shutdown() elif state == EventTypes.DATACOLLECT_STATE: session.data_collect() elif state == EventTypes.DEFINITION_STATE: session.clear() response.result = True except KeyError: response.result = False return response def GetSessionOptions(self, request, context): logging.debug("get session options: %s", request) session = self.get_session(request.id, context) config = session.options.get_configs() defaults = session.options.default_values() defaults.update(config) groups = get_config_groups(defaults, session.options) response = core_pb2.GetSessionOptionsResponse() response.groups.extend(groups) return response def SetSessionOptions(self, request, context): logging.debug("set session options: %s", request) session = self.get_session(request.id, context) session.options.set_configs(request.config) response = core_pb2.SetSessionOptionsResponse() response.result = True return response def GetSession(self, request, context): logging.debug("get session: %s", request) session = self.get_session(request.id, context) response = core_pb2.GetSessionResponse() response.state = session.state for node_id in session.objects: node = session.objects[node_id] if not isinstance(node.objid, int): continue node_proto = response.nodes.add() node_proto.id = node.objid node_proto.name = node.name node_proto.type = nodeutils.get_node_type(node.__class__).value model = getattr(node, "type", None) if model is not None: node_proto.model = model update_proto( node_proto.position, x=node.position.x, y=node.position.y, z=node.position.z ) services = getattr(node, "services", []) if services is None: services = [] services = [x.name for x in services] node_proto.services.extend(services) emane_model = None if nodeutils.is_node(node, NodeTypes.EMANE): emane_model = node.model.name if emane_model is not None: node_proto.emane = emane_model links_data = node.all_link_data(0) for link_data in links_data: link = response.links.add() convert_link(session, link_data, link) return response def NodeEvents(self, request, context): session = self.get_session(request.id, context) queue = Queue() session.node_handlers.append(lambda x: queue.put(x)) while self._is_running(context): try: node = queue.get(timeout=1) node_event = core_pb2.NodeEvent() update_proto( node_event.node, id=node.id, name=node.name, model=node.model ) update_proto( node_event.node.position, x=node.x_position, y=node.y_position ) services = node.services or "" node_event.node.services.extend(services.split("|")) yield node_event except Empty: continue self._cancel_stream(context) def LinkEvents(self, request, context): session = self.get_session(request.id, context) queue = Queue() session.link_handlers.append(lambda x: queue.put(x)) while self._is_running(context): try: event = queue.get(timeout=1) link_event = core_pb2.LinkEvent() if event.interface1_id is not None: interface_one = link_event.link.interface_one update_proto( interface_one, id=event.interface1_id, name=event.interface1_name, mac=convert_value(event.interface1_mac), ip4=convert_value(event.interface1_ip4), ip4mask=event.interface1_ip4_mask, ip6=convert_value(event.interface1_ip6), ip6mask=event.interface1_ip6_mask, ) if event.interface2_id is not None: interface_two = link_event.link.interface_two update_proto( interface_two, id=event.interface2_id, name=event.interface2_name, mac=convert_value(event.interface2_mac), ip4=convert_value(event.interface2_ip4), ip4mask=event.interface2_ip4_mask, ip6=convert_value(event.interface2_ip6), ip6mask=event.interface2_ip6_mask, ) link_event.message_type = event.message_type update_proto( link_event.link, type=event.link_type, node_one=event.node1_id, node_two=event.node2_id ) update_proto( link_event.link.options, opaque=event.opaque, jitter=event.jitter, key=event.key, mburst=event.mburst, mer=event.mer, per=event.per, bandwidth=event.bandwidth, burst=event.burst, delay=event.delay, dup=event.dup, unidirectional=event.unidirectional ) yield link_event except Empty: continue self._cancel_stream(context) def SessionEvents(self, request, context): session = self.get_session(request.id, context) queue = Queue() session.event_handlers.append(lambda x: queue.put(x)) while self._is_running(context): try: event = queue.get(timeout=1) session_event = core_pb2.SessionEvent() event_time = event.time if event_time is not None: event_time = float(event_time) update_proto( session_event, node=event.node, event=event.event_type, name=event.name, data=event.data, time=event_time, session=session.session_id ) yield session_event except Empty: continue self._cancel_stream(context) def ConfigEvents(self, request, context): session = self.get_session(request.id, context) queue = Queue() session.config_handlers.append(lambda x: queue.put(x)) while self._is_running(context): try: event = queue.get(timeout=1) config_event = core_pb2.ConfigEvent() update_proto( config_event, message_type=event.message_type, node=event.node, object=event.object, type=event.type, captions=event.captions, bitmap=event.bitmap, data_values=event.data_values, possible_values=event.possible_values, groups=event.groups, session=event.session, interface=event.interface_number, network_id=event.network_id, opaque=event.opaque ) config_event.data_types.extend(event.data_types) yield config_event except Empty: continue self._cancel_stream(context) def ExceptionEvents(self, request, context): session = self.get_session(request.id, context) queue = Queue() session.exception_handlers.append(lambda x: queue.put(x)) while self._is_running(context): try: event = queue.get(timeout=1) exception_event = core_pb2.ExceptionEvent() update_proto( exception_event, node=event.node, session=int(event.session), level=event.level.value, source=event.source, date=event.date, text=event.text, opaque=event.opaque ) yield exception_event except Empty: continue self._cancel_stream(context) def FileEvents(self, request, context): session = self.get_session(request.id, context) queue = Queue() session.file_handlers.append(lambda x: queue.put(x)) while self._is_running(context): try: event = queue.get(timeout=1) file_event = core_pb2.FileEvent() update_proto( file_event, message_type=event.message_type, node=event.node, name=event.name, mode=event.mode, number=event.number, type=event.type, source=event.source, session=event.session, data=event.data, compressed_data=event.compressed_data ) yield file_event except Empty: continue self._cancel_stream(context) def CreateNode(self, request, context): logging.debug("create node: %s", request) session = self.get_session(request.session, context) node_id = request.id node_type = request.type if node_type is None: node_type = NodeTypes.DEFAULT.value node_type = NodeTypes(node_type) node_options = NodeOptions(name=request.name, model=request.model) node_options.icon = request.icon node_options.opaque = request.opaque node_options.services = request.services position = request.position node_options.set_position(position.x, position.y) node_options.set_location(position.lat, position.lon, position.alt) node = session.add_node(_type=node_type, _id=node_id, node_options=node_options) # configure emane if provided emane_model = request.emane if emane_model: session.emane.set_model_config(node_id, emane_model) response = core_pb2.CreateNodeResponse() response.id = node.objid return response def GetNode(self, request, context): logging.debug("get node: %s", request) session = self.get_session(request.session, context) node = self.get_node(session, request.id, context) response = core_pb2.GetNodeResponse() for interface_id, interface in node._netif.iteritems(): net_id = None if interface.net: net_id = interface.net.objid interface_proto = response.interfaces.add() interface_proto.id = interface_id interface_proto.netid = net_id interface_proto.name = interface.name interface_proto.mac = str(interface.hwaddr) interface_proto.mtu = interface.mtu interface_proto.flowid = interface.flow_id emane_model = None if nodeutils.is_node(node, NodeTypes.EMANE): emane_model = node.model.name update_proto( response.node, name=node.name, type=nodeutils.get_node_type(node.__class__).value, emane=emane_model, model=node.type ) update_proto( response.node.position, x=node.position.x, y=node.position.y, z=node.position.z, ) services = [x.name for x in getattr(node, "services", [])] response.node.services.extend(services) return response def EditNode(self, request, context): logging.debug("edit node: %s", request) session = self.get_session(request.session, context) node_id = request.id node_options = NodeOptions() x = request.position.x y = request.position.y node_options.set_position(x, y) lat = request.position.lat lon = request.position.lon alt = request.position.alt node_options.set_location(lat, lon, alt) result = session.update_node(node_id, node_options) response = core_pb2.EditNodeResponse() response.result = result return response def DeleteNode(self, request, context): logging.debug("delete node: %s", request) session = self.get_session(request.session, context) response = core_pb2.DeleteNodeResponse() response.result = session.delete_node(request.id) return response def GetNodeLinks(self, request, context): logging.debug("get node links: %s", request) session = self.get_session(request.session, context) node = self.get_node(session, request.id, context) response = core_pb2.GetNodeLinksResponse() links_data = node.all_link_data(0) for link_data in links_data: link = response.links.add() convert_link(session, link_data, link) return response def CreateLink(self, request, context): logging.debug("create link: %s", request) session = self.get_session(request.session, context) node_one = request.link.node_one node_two = request.link.node_two interface_one = None interface_one_data = request.link.interface_one if interface_one_data: name = interface_one_data.name if name == "": name = None mac = interface_one_data.mac if mac == "": mac = None interface_one = InterfaceData( _id=interface_one_data.id, name=name, mac=mac, ip4=interface_one_data.ip4, ip4_mask=interface_one_data.ip4mask, ip6=interface_one_data.ip6, ip6_mask=interface_one_data.ip6mask, ) interface_two = None interface_two_data = request.link.interface_two if interface_two_data: name = interface_two_data.name if name == "": name = None mac = interface_two_data.mac if mac == "": mac = None interface_two = InterfaceData( _id=interface_two_data.id, name=name, mac=mac, ip4=interface_two_data.ip4, ip4_mask=interface_two_data.ip4mask, ip6=interface_two_data.ip6, ip6_mask=interface_two_data.ip6mask, ) link_type = None link_type_value = request.link.type if link_type_value is not None: link_type = LinkTypes(link_type_value) options_data = request.link.options link_options = LinkOptions(_type=link_type) if options_data: link_options.delay = options_data.delay link_options.bandwidth = options_data.bandwidth link_options.per = options_data.per link_options.dup = options_data.dup link_options.jitter = options_data.jitter link_options.mer = options_data.mer link_options.burst = options_data.burst link_options.mburst = options_data.mburst link_options.unidirectional = options_data.unidirectional link_options.key = options_data.key link_options.opaque = options_data.opaque session.add_link(node_one, node_two, interface_one, interface_two, link_options=link_options) response = core_pb2.CreateLinkResponse() response.result = True return response def EditLink(self, request, context): logging.debug("edit link: %s", request) session = self.get_session(request.session, context) node_one = request.node_one node_two = request.node_two interface_one_id = request.interface_one interface_two_id = request.interface_two options_data = request.options link_options = LinkOptions() link_options.delay = options_data.delay link_options.bandwidth = options_data.bandwidth link_options.per = options_data.per link_options.dup = options_data.dup link_options.jitter = options_data.jitter link_options.mer = options_data.mer link_options.burst = options_data.burst link_options.mburst = options_data.mburst link_options.unidirectional = options_data.unidirectional link_options.key = options_data.key link_options.opaque = options_data.opaque session.update_link(node_one, node_two, interface_one_id, interface_two_id, link_options) response = core_pb2.EditLinkResponse() response.result = True return response def DeleteLink(self, request, context): logging.debug("delete link: %s", request) session = self.get_session(request.session, context) node_one = request.node_one node_two = request.node_two interface_one = request.interface_one interface_two = request.interface_two session.delete_link(node_one, node_two, interface_one, interface_two) response = core_pb2.DeleteLinkResponse() response.result = True return response def GetHooks(self, request, context): logging.debug("get hooks: %s", request) session = self.get_session(request.session, context) response = core_pb2.GetHooksResponse() for state, state_hooks in session._hooks.iteritems(): for file_name, file_data in state_hooks: hook = response.hooks.add() hook.state = state hook.file = file_name hook.data = file_data return response def AddHook(self, request, context): logging.debug("add hook: %s", request) session = self.get_session(request.session, context) hook = request.hook session.add_hook(hook.state, hook.file, None, hook.data) response = core_pb2.AddHookResponse() response.result = True return response def GetMobilityConfigs(self, request, context): logging.debug("get mobility configs: %s", request) session = self.get_session(request.session, context) response = core_pb2.GetMobilityConfigsResponse() for node_id, model_config in session.mobility.node_configurations.iteritems(): if node_id == -1: continue for model_name in model_config.iterkeys(): if model_name != Ns2ScriptedMobility.name: continue config = session.mobility.get_model_config(node_id, model_name) groups = get_config_groups(config, Ns2ScriptedMobility) mobility_config = response.configs[node_id] mobility_config.groups.extend(groups) return response def GetMobilityConfig(self, request, context): logging.debug("get mobility config: %s", request) session = self.get_session(request.session, context) config = session.mobility.get_model_config(request.id, Ns2ScriptedMobility.name) groups = get_config_groups(config, Ns2ScriptedMobility) response = core_pb2.GetMobilityConfigResponse() response.groups.extend(groups) return response def SetMobilityConfig(self, request, context): logging.debug("set mobility config: %s", request) session = self.get_session(request.session, context) session.mobility.set_model_config(request.id, Ns2ScriptedMobility.name, request.config) response = core_pb2.SetMobilityConfigResponse() response.result = True return response def MobilityAction(self, request, context): logging.debug("mobility action: %s", request) session = self.get_session(request.session, context) node = self.get_node(session, request.id, context) response = core_pb2.MobilityActionResponse() response.result = True if request.action == core_pb2.MOBILITY_START: node.mobility.start() elif request.action == core_pb2.MOBILITY_PAUSE: node.mobility.pause() elif request.action == core_pb2.MOBILITY_STOP: node.mobility.stop(move_initial=True) else: response.result = False return response def GetServices(self, request, context): logging.debug("get services: %s", request) response = core_pb2.GetServicesResponse() for service in ServiceManager.services.itervalues(): service_proto = response.services.add() service_proto.group = service.group service_proto.name = service.name return response def GetServiceDefaults(self, request, context): logging.debug("get service defaults: %s", request) session = self.get_session(request.session, context) response = core_pb2.GetServiceDefaultsResponse() for node_type in session.services.default_services: services = session.services.default_services[node_type] service_defaults = response.defaults.add() service_defaults.node_type = node_type service_defaults.services.extend(services) return response def SetServiceDefaults(self, request, context): logging.debug("set service defaults: %s", request) session = self.get_session(request.session, context) session.services.default_services.clear() for service_defaults in request.defaults: session.services.default_services[service_defaults.node_type] = service_defaults.services response = core_pb2.SetServiceDefaultsResponse() response.result = True return response def GetNodeService(self, request, context): logging.debug("get node service: %s", request) session = self.get_session(request.session, context) service = session.services.get_service(request.id, request.service, default_service=True) response = core_pb2.GetNodeServiceResponse() response.service.executables.extend(service.executables) response.service.dependencies.extend(service.dependencies) response.service.dirs.extend(service.dirs) response.service.configs.extend(service.configs) response.service.startup.extend(service.startup) response.service.validate.extend(service.validate) response.service.validation_mode = service.validation_mode.value response.service.validation_timer = service.validation_timer response.service.shutdown.extend(service.shutdown) if service.meta: response.service.meta = service.meta return response def GetNodeServiceFile(self, request, context): logging.debug("get node service file: %s", request) session = self.get_session(request.session, context) node = self.get_node(session, request.id, context) service = None for current_service in node.services: if current_service.name == request.service: service = current_service break response = core_pb2.GetNodeServiceFileResponse() if not service: return response file_data = session.services.get_service_file(node, request.service, request.file) response.data = file_data.data return response def SetNodeService(self, request, context): logging.debug("set node service: %s", request) session = self.get_session(request.session, context) # guarantee custom service exists session.services.set_service(request.id, request.service) service = session.services.get_service(request.id, request.service) service.startup = tuple(request.startup) service.validate = tuple(request.validate) service.shutdown = tuple(request.shutdown) response = core_pb2.SetNodeServiceResponse() response.result = True return response def SetNodeServiceFile(self, request, context): logging.debug("set node service file: %s", request) session = self.get_session(request.session, context) session.services.set_service_file(request.id, request.service, request.file, request.data) response = core_pb2.SetNodeServiceFileResponse() response.result = True return response def ServiceAction(self, request, context): logging.debug("service action: %s", request) session = self.get_session(request.session, context) node = self.get_node(session, request.id, context) service = None for current_service in node.services: if current_service.name == request.service: service = current_service break response = core_pb2.ServiceActionResponse() response.result = False if not service: return response status = -1 if request.action == core_pb2.START: status = session.services.startup_service(node, service, wait=True) elif request.action == core_pb2.STOP: status = session.services.stop_service(node, service) elif request.action == core_pb2.RESTART: status = session.services.stop_service(node, service) if not status: status = session.services.startup_service(node, service, wait=True) elif request.action == core_pb2.VALIDATE: status = session.services.validate_service(node, service) if not status: response.result = True return response def GetWlanConfig(self, request, context): logging.debug("get wlan config: %s", request) session = self.get_session(request.session, context) config = session.mobility.get_model_config(request.id, BasicRangeModel.name) groups = get_config_groups(config, BasicRangeModel) response = core_pb2.GetWlanConfigResponse() response.groups.extend(groups) return response def SetWlanConfig(self, request, context): logging.debug("set wlan config: %s", request) session = self.get_session(request.session, context) session.mobility.set_model_config(request.id, BasicRangeModel.name, request.config) response = core_pb2.SetWlanConfigResponse() response.result = True return response def GetEmaneConfig(self, request, context): logging.debug("get emane config: %s", request) session = self.get_session(request.session, context) config = session.emane.get_configs() groups = get_config_groups(config, session.emane.emane_config) response = core_pb2.GetEmaneConfigResponse() response.groups.extend(groups) return response def SetEmaneConfig(self, request, context): logging.debug("set emane config: %s", request) session = self.get_session(request.session, context) session.emane.set_configs(request.config) response = core_pb2.SetEmaneConfigResponse() response.result = True return response def GetEmaneModels(self, request, context): logging.debug("get emane models: %s", request) session = self.get_session(request.session, context) models = [] for model in session.emane.models.keys(): if len(model.split("_")) != 2: continue models.append(model) response = core_pb2.GetEmaneModelsResponse() response.models.extend(models) return response def GetEmaneModelConfig(self, request, context): logging.debug("get emane model config: %s", request) session = self.get_session(request.session, context) model = session.emane.models[request.model] config = session.emane.get_model_config(request.id, request.model) groups = get_config_groups(config, model) response = core_pb2.GetEmaneModelConfigResponse() response.groups.extend(groups) return response def SetEmaneModelConfig(self, request, context): logging.debug("set emane model config: %s", request) session = self.get_session(request.session, context) session.emane.set_model_config(request.id, request.model, request.config) response = core_pb2.SetEmaneModelConfigResponse() response.result = True return response def GetEmaneModelConfigs(self, request, context): logging.debug("get emane model configs: %s", request) session = self.get_session(request.session, context) response = core_pb2.GetEmaneModelConfigsResponse() for node_id, model_config in session.emane.node_configurations.iteritems(): if node_id == -1: continue for model_name in model_config.iterkeys(): model = session.emane.models[model_name] config = session.emane.get_model_config(node_id, model_name) config_groups = get_config_groups(config, model) node_configurations = response.configs[node_id] node_configurations.model = model_name node_configurations.groups.extend(config_groups) return response def SaveXml(self, request, context): logging.debug("save xml: %s", request) session = self.get_session(request.session, context) _, temp_path = tempfile.mkstemp() session.save_xml(temp_path) with open(temp_path, "rb") as xml_file: data = xml_file.read() response = core_pb2.SaveXmlResponse() response.data = data return response def OpenXml(self, request, context): logging.debug("open xml: %s", request) session = self.coreemu.create_session() session.set_state(EventTypes.CONFIGURATION_STATE) _, temp_path = tempfile.mkstemp() with open(temp_path, "wb") as xml_file: xml_file.write(request.data) response = core_pb2.OpenXmlResponse() try: session.open_xml(temp_path, start=True) response.session = session.session_id response.result = True except: response.result = False logging.exception("error opening session file") self.coreemu.delete_session(session.session_id) return response