src/nepi/resources/ns3/ns3server.py

   1 #
   2 #    NEPI, a framework to manage network experiments
   3 #    Copyright (C) 2014 INRIA
   4 #
   5 #    This program is free software: you can redistribute it and/or modify
   6 #    it under the terms of the GNU General Public License as published by
   7 #    the Free Software Foundation, either version 3 of the License, or
   8 #    (at your option) any later version.
   9 #
  10 #    This program is distributed in the hope that it will be useful,
  11 #    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 #    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 #    GNU General Public License for more details.
  14 #
  15 #    You should have received a copy of the GNU General Public License
  16 #    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  17 #
  18 # Author: Alina Quereilhac <alina.quereilhac@inria.fr>
  19
  20 import base64
  21 import cPickle
  22 import errno
  23 import logging
  24 import os
  25 import socket
  26 import sys
  27
  28 from optparse import OptionParser, SUPPRESS_HELP
  29
  30 from ns3wrapper import NS3Wrapper
  31
  32 class NS3WrapperMessage:
  33     CREATE = "CREATE"
  34     FACTORY = "FACTORY"
  35     INVOKE = "INVOKE"
  36     SET = "SET"
  37     GET = "GET"
  38     FLUSH = "FLUSH"
  39     START = "START"
  40     STOP = "STOP"
  41     SHUTDOWN = "SHUTDOWN"
  42
  43 def handle_message(ns3_wrapper, msg_type, args, kwargs):
  44     if msg_type == NS3WrapperMessage.SHUTDOWN:
  45         ns3_wrapper.shutdown()
  46
  47         return "BYEBYE"
  48
  49     if msg_type == NS3WrapperMessage.STOP:
  50         time = kwargs.get("time")
  51
  52         ns3_wrapper.stop(time=time)
  53
  54         return "STOPPED"
  55
  56     if msg_type == NS3WrapperMessage.START:
  57         ns3_wrapper.start()
  58
  59         return "STARTED"
  60
  61     if msg_type == NS3WrapperMessage.CREATE:
  62         clazzname = args.pop(0)
  63
  64         return ns3_wrapper.create(clazzname, *args)
  65
  66     if msg_type == NS3WrapperMessage.FACTORY:
  67         type_name = args.pop(0)
  68
  69         return ns3_wrapper.factory(type_name, **kwargs)
  70
  71     if msg_type == NS3WrapperMessage.INVOKE:
  72         uuid = args.pop(0)
  73         operation = args.pop(0)
  74
  75         return ns3_wrapper.invoke(uuid, operation, *args, **kwargs)
  76
  77     if msg_type == NS3WrapperMessage.GET:
  78         uuid = args.pop(0)
  79         name = args.pop(0)
  80
  81         return ns3_wrapper.get(uuid, name)
  82
  83     if msg_type == NS3WrapperMessage.SET:
  84         uuid = args.pop(0)
  85         name = args.pop(0)
  86         value = args.pop(0)
  87
  88         return ns3_wrapper.set(uuid, name, value)
  89
  90     if msg_type == NS3WrapperMessage.FLUSH:
  91         # Forces flushing output and error streams.
  92         # NS-3 output will stay unflushed until the program exits or
  93         # explicit invocation flush is done
  94         sys.stdout.flush()
  95         sys.stderr.flush()
  96
  97         ns3_wrapper.logger.debug("FLUSHED")
  98
  99         return "FLUSHED"
 100
 101 def create_socket(socket_name):
 102     sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
 103     sock.bind(socket_name)
 104     return sock
 105
 106 def recv_msg(conn):
 107     msg = []
 108     chunk = ''
 109
 110     while '\n' not in chunk:
 111         try:
 112             chunk = conn.recv(1024)
 113         except (OSError, socket.error), e:
 114             if e[0] != errno.EINTR:
 115                 raise
 116             # Ignore eintr errors
 117             continue
 118
 119         if chunk:
 120             msg.append(chunk)
 121         else:
 122             # empty chunk = EOF
 123             break
 124
 125     msg = ''.join(msg).strip()
 126
 127     # The message is formatted as follows:
 128     #   MESSAGE_TYPE|args|kwargs
 129     #
 130     #   where MESSAGE_TYPE, args and kwargs are pickld and enoded in base64
 131
 132     def decode(item):
 133         item = base64.b64decode(item).rstrip()
 134         return cPickle.loads(item)
 135
 136     decoded = map(decode, msg.split("|"))
 137
 138     # decoded message
 139     dmsg_type = decoded.pop(0)
 140     dargs = list(decoded.pop(0)) # transforming touple into list
 141     dkwargs = decoded.pop(0)
 142
 143     return (dmsg_type, dargs, dkwargs)
 144
 145 def send_reply(conn, reply):
 146     encoded = base64.b64encode(cPickle.dumps(reply))
 147     conn.send("%s\n" % encoded)
 148
 149 def get_options():
 150     usage = ("usage: %prog -S <socket-name> -L <ns-log>  -D <enable-dump> -v ")
 151
 152     parser = OptionParser(usage = usage)
 153
 154     parser.add_option("-S", "--socket-name", dest="socket_name",
 155         help = "Name for the unix socket used to interact with this process",
 156         default = "tap.sock", type="str")
 157
 158     parser.add_option("-L", "--ns-log", dest="ns_log",
 159         help = "NS_LOG environmental variable to be set",
 160         default = "", type="str")
 161
 162     parser.add_option("-D", "--enable-dump", dest="enable_dump",
 163         help = "Enable dumping the remote executed ns-3 commands to a script "
 164             "in order to later reproduce and debug the experiment",
 165         action = "store_true",
 166         default = False)
 167
 168     parser.add_option("-v", "--verbose",
 169         help="Print debug output",
 170         action="store_true",
 171         dest="verbose", default=False)
 172
 173     (options, args) = parser.parse_args()
 174
 175     return (options.socket_name, options.verbose, options.ns_log,
 176             options.enable_dump)
 177
 178 def run_server(socket_name, level = logging.INFO, ns_log = None,
 179         enable_dump = False):
 180
 181     # Sets NS_LOG environmental variable for NS debugging
 182     if ns_log:
 183         os.environ["NS_LOG"] = ns_log
 184
 185     ###### ns-3 wrapper instantiation
 186
 187     ns3_wrapper = NS3Wrapper(loglevel=level, enable_dump = enable_dump)
 188
 189     ns3_wrapper.logger.info("STARTING...")
 190
 191     # create unix socket to receive instructions
 192     sock = create_socket(socket_name)
 193     sock.listen(0)
 194
 195     # wait for messages to arrive and process them
 196     stop = False
 197
 198     while not stop:
 199         conn, addr = sock.accept()
 200         conn.settimeout(5)
 201
 202         try:
 203             (msg_type, args, kwargs) = recv_msg(conn)
 204         except socket.timeout, e:
 205             # Ingore time-out
 206             continue
 207
 208         if not msg_type:
 209             # Ignore - connection lost
 210             continue
 211
 212         if msg_type == NS3WrapperMessage.SHUTDOWN:
 213            stop = True
 214
 215         try:
 216             reply = handle_message(ns3_wrapper, msg_type, args, kwargs)
 217         except:
 218             import traceback
 219             err = traceback.format_exc()
 220             ns3_wrapper.logger.error(err)
 221             raise
 222
 223         try:
 224             send_reply(conn, reply)
 225         except socket.error:
 226             import traceback
 227             err = traceback.format_exc()
 228             ns3_wrapper.logger.error(err)
 229             raise
 230
 231     ns3_wrapper.logger.info("EXITING...")
 232
 233 if __name__ == '__main__':
 234
 235     (socket_name, verbose, ns_log, enable_dump) = get_options()
 236
 237     ## configure logging
 238     FORMAT = "%(asctime)s %(name)s %(levelname)-4s %(message)s"
 239     level = logging.DEBUG if verbose else logging.INFO
 240
 241     logging.basicConfig(format = FORMAT, level = level)
 242
 243     ## Run the server
 244     run_server(socket_name, level, ns_log, enable_dump)
 245